diff --git "a/data.jsonl" "b/data.jsonl"
--- "a/data.jsonl"
+++ "b/data.jsonl"
@@ -7,4 +7,124 @@
{"text": "# Create an app to visualize sin, cos with slider and chart from taipy.gui import Gui from math import sin, cos, pi state = { \"frequency\": 1, \"decay\": 0.01, \"data\": [] } page = \"\"\" # Sine and Cosine Functions Frequency: <|{frequency}|slider|min=0|max=10|step=0.1|on_change=update|> Decay: <|{decay}|slider|min=0|max=1|step=0.01|on_change=update|> <|Data|chart|data={data}|> \"\"\" def update(state): x = [i/10 for i in range(100)] y1 = [sin(i*state.frequency*2*pi) * exp(-i*state.decay) for i in x] y2 = [cos(i*state.frequency*2*pi) * exp(-i*state.decay) for i in x] state.data = [ {\"name\": \"Sine\", \"data\": y1}, {\"name\": \"Cosine\", \"data\": y2} ] Gui(page).run(use_reloader=True, state=state)"}
{"text": "# Create app to visualize country population import numpy as np import pandas as pd from taipy.gui import Markdown from data.data import data selected_country = 'France' data_country_date = None representation_selector = ['Cumulative', 'Density'] selected_representation = representation_selector[0] layout = {'barmode':'stack', \"hovermode\":\"x\"} options = {\"unselected\":{\"marker\":{\"opacity\":0.5}}} def initialize_case_evolution(data, selected_country='France'): # Aggregation of the dataframe to erase the regions that will not be used here data_country_date = data.groupby([\"Country/Region\",'Date'])\\ .sum()\\ .reset_index() # a country is selected, here France by default data_country_date = data_country_date.loc[data_country_date['Country/Region']==selected_country] return data_country_date data_country_date = initialize_case_evolution(data) pie_chart = pd.DataFrame({\"labels\": [\"Deaths\", \"Recovered\", \"Confirmed\"],\"values\": [data_country_date.iloc[-1, 6], data_country_date.iloc[-1, 5], data_country_date.iloc[-1, 4]]}) def convert_density(state): if state.selected_representation == 'Density': df_temp = state.data_country_date.copy() df_temp['Deaths'] = df_temp['Deaths'].diff().fillna(0) df_temp['Recovered'] = df_temp['Recovered'].diff().fillna(0) df_temp['Confirmed'] = df_temp['Confirmed'].diff().fillna(0) state.data_country_date = df_temp else: state.data_country_date = initialize_case_evolution(data, state.selected_country) def on_change_country(state): # state contains all the Gui variables and this is through this state variable that we can update the Gui # state.selected_country, state.data_country_date, ... # update data_country_date with the right country (use initialize_case_evolution) print(\"Chosen country: \", state.selected_country) state.data_country_date = initialize_case_evolution(data, state.selected_country) state.pie_chart = pd.DataFrame({\"labels\": [\"Deaths\", \"Recovered\", \"Confirmed\"], \"values\": [state.data_country_date.iloc[-1, 6], state.data_country_date.iloc[-1, 5], state.data_country_date.iloc[-1, 4]]}) convert_density(state) page =\"\"\" # **Country**{: .color-primary} Statistics <|layout|columns=1 1 1| <|{selected_country}|selector|lov={selector_country}|on_change=on_change_country|dropdown|label=Country|> <|{selected_representation}|toggle|lov={representation_selector}|on_change=convert_density|> |> <|layout|columns=1 1 1 1|gap=50px| <|card| **Deaths**{: .color-primary} <|{'{:,}'.format(int(data_country_date.iloc[-1]['Deaths'])).replace(',', ' ')}|text|class_name=h2|> |> <|card| **Recovered**{: .color-primary} <|{'{:,}'.format(int(data_country_date.iloc[-1]['Recovered'])).replace(',', ' ')}|text|class_name=h2|> |> <|card| **Confirmed**{: .color-primary} <|{'{:,}'.format(int(data_country_date.iloc[-1]['Confirmed'])).replace(',', ' ')}|text|class_name=h2|> |> |> <|layout|columns=2 1| <|{data_country_date}|chart|type=bar|x=Date|y[3]=Deaths|y[2]=Recovered|y[1]=Confirmed|layout={layout}|options={options}|title=Covid Evolution|> <|{pie_chart}|chart|type=pie|values=values|labels=labels|title=Distribution between cases|> |> \"\"\" Gui(page).run(use_reloader=True, state=state)"}
{"text": "# Create Taipy app to generate mandelbrot fractals from taipy import Gui import numpy as np from PIL import Image import matplotlib.pyplot as plt WINDOW_SIZE = 500 cm = plt.cm.get_cmap(\"viridis\") def generate_mandelbrot( center: int = WINDOW_SIZE / 2, dx_range: int = 1000, dx_start: float = -0.12, dy_range: float = 1000, dy_start: float = -0.82, iterations: int = 50, max_value: int = 200, i: int = 0, ) -> str: mat = np.zeros((WINDOW_SIZE, WINDOW_SIZE)) for y in range(WINDOW_SIZE): for x in range(WINDOW_SIZE): dx = (x - center) / dx_range + dx_start dy = (y - center) / dy_range + dy_start a = dx b = dy for t in range(iterations): d = (a * a) - (b * b) + dx b = 2 * (a * b) + dy a = d h = d > max_value if h is True: mat[x, y] = t colored_mat = cm(mat / mat.max()) im = Image.fromarray((colored_mat * 255).astype(np.uint8)) path = f\"mandelbrot_{i}.png\" im.save(path) return path def generate(state): state.i = state.i + 1 state.path = generate_mandelbrot( dx_start=-state.dx_start / 100, dy_start=(state.dy_start - 100) / 100, iterations=state.iterations, i=state.i, ) i = 0 dx_start = 11 dy_start = 17 iterations = 50 path = generate_mandelbrot( dx_start=-dx_start / 100, dy_start=(dy_start - 100) / 100, ) page = \"\"\" # Mandelbrot Generator <|layout|columns=35 65| Display image from path <|{path}|image|width=500px|height=500px|class_name=img|> Iterations: Create a slider to select iterations <|{iterations}|slider|min=10|max=50|continuous=False|on_change=generate|> X Position: <|{dy_start}|slider|min=0|max=100|continuous=False|on_change=generate|> Y Position: Slider dx_start <|{dx_start}|slider|min=0|max=100|continuous=False|on_change=generate|> |> \"\"\" Gui(page).run(title=\"Mandelbrot Generator\") "}
-{"text": "# Create app to auto generate Tweeter status import logging import random import re # Import from 3rd party libraries from taipy.gui import Gui, notify, state import taipy # Import modules import oai # Configure logger logging.basicConfig(format=\"\\n%(asctime)s\\n%(message)s\", level=logging.INFO, force=True) def error_prompt_flagged(state, prompt): \"\"\"Notify user that a prompt has been flagged.\"\"\" notify(state, \"error\", \"Prompt flagged as inappropriate.\") logging.info(f\"Prompt flagged as inappropriate: {prompt}\") def error_too_many_requests(state): \"\"\"Notify user that too many requests have been made.\"\"\" notify( state, \"error\", \"Too many requests. Please wait a few seconds before generating another text or image.\", ) logging.info(f\"Session request limit reached: {state.n_requests}\") state.n_requests = 1 # Define functions def generate_text(state): \"\"\"Generate Tweet text.\"\"\" state.tweet = \"\" state.image = None # Check the number of requests done by the user if state.n_requests >= 5: error_too_many_requests(state) return # Check if the user has put a topic if state.topic == \"\": notify(state, \"error\", \"Please enter a topic\") return # Create the prompt and add a style or not if state.style == \"\": state.prompt = ( f\"Write a {state.mood}Tweet about {state.topic} in less than 120 characters \" f\"and with the style of {state.style}:\\n\\n\\n\\n\" ) else: state.prompt = f\"Write a {state.mood}Tweet about {state.topic} in less than 120 characters:\\n\\n\" # openai configured and check if text is flagged openai = oai.Openai() flagged = openai.moderate(state.prompt) if flagged: error_prompt_flagged(state, f\"Prompt: {state.prompt}\\n\") return else: # Generate the tweet state.n_requests += 1 state.tweet = openai.complete(state.prompt).strip().replace('\"', \"\") # Notify the user in console and in the GUI logging.info( f\"Topic: {state.prompt}{state.mood}{state.style}\\n\" f\"Tweet: {state.tweet}\" ) notify(state, \"success\", \"Tweet created!\") def generate_image(state): \"\"\"Generate Tweet image.\"\"\" notify(state, \"info\", \"Generating image...\") # Check the number of requests done by the user if state.n_requests >= 5: error_too_many_requests(state) return state.image = None # Creates the prompt prompt_wo_hashtags = re.sub(\"#[A-Za-z0-9_]+\", \"\", state.prompt) processing_prompt = ( \"Create a detailed but brief description of an image that captures \" f\"the essence of the following text:\\n{prompt_wo_hashtags}\\n\\n\" ) # Openai configured and check if text is flagged openai = oai.Openai() flagged = openai.moderate(processing_prompt) if flagged: error_prompt_flagged(state, processing_prompt) return else: state.n_requests += 1 # Generate the prompt that will create the image processed_prompt = ( openai.complete(prompt=processing_prompt, temperature=0.5, max_tokens=40) .strip() .replace('\"', \"\") .split(\".\")[0] + \".\" ) # Generate the image state.image = openai.image(processed_prompt) # Notify the user in console and in the GUI logging.info(f\"Tweet: {state.prompt}\\nImage prompt: {processed_prompt}\") notify(state, \"success\", f\"Image created!\") def feeling_lucky(state): \"\"\"Generate a feeling-lucky tweet.\"\"\" with open(\"moods.txt\") as f: sample_moods = f.read().splitlines() state.topic = \"an interesting topic\" state.mood = random.choice(sample_moods) state.style = \"\" generate_text(state) # Variables tweet = \"\" prompt = \"\" n_requests = 0 topic = \"AI\" mood = \"inspirational\" style = \"elonmusk\" image = None # Called whever there is a problem def on_exception(state, function_name: str, ex: Exception): logging.error(f\"Problem {ex} \\nin {function_name}\") notify(state, \"error\", f\"Problem {ex} \\nin {function_name}\") def update_documents(state: taipy.gui.state, docs: list[dict]) -> None: \"\"\" Updates a partial with a list of documents Args: state: The state of the GUI docs: A list of documents \"\"\" updated_part = \"\" for doc in docs: title = doc[\"title\"] summary = doc[\"summary\"] link = doc[\"link\"] updated_part += f\"\"\"
\"\"\" state.p.update_content(state, updated_part) # Markdown for the entire page ## ## \"text\" here is just a name given to my part/my section ## it has no meaning in the code page = \"\"\" <|container| # **Generate**{: .color-primary} Tweets This mini-app generates Tweets using OpenAI's GPT-3 based [Davinci model](https://beta.openai.com/docs/models/overview) for texts and [DALL\u00b7E](https://beta.openai.com/docs/guides/images) for images. You can find the code on [GitHub](https://github.com/Avaiga/demo-tweet-generation) and the original author on [Twitter](https://twitter.com/kinosal).
<|layout|columns=1 1 1|gap=30px|class_name=card| |topic> |mood> |style> Create a Generate text button <|Generate text|button|on_action=generate_text|label=Generate text|> <|Feeling lucky|button|on_action=feeling_lucky|label=Feeling Lucky|> |> --- ### Generated **Tweet**{: .color-primary} Create a text input for the tweet <|{tweet}|input|multiline|label=Resulting tweet|class_name=fullwidth|>
<|Generate image|button|on_action=generate_image|label=Generate image|active={prompt!=\"\" and tweet!=\"\"}|>
<|{image}|image|height=400px|> |image> Break line **Code from [@kinosal](https://twitter.com/kinosal)** Original code can be found [here](https://github.com/kinosal/tweet) |> \"\"\" if __name__ == \"__main__\": Gui(page).run(dark_mode=False, port=5089) "}
\ No newline at end of file
+{"text": "# Create app to auto generate Tweeter status import logging import random import re # Import from 3rd party libraries from taipy.gui import Gui, notify, state import taipy # Import modules import oai # Configure logger logging.basicConfig(format=\"\\n%(asctime)s\\n%(message)s\", level=logging.INFO, force=True) def error_prompt_flagged(state, prompt): \"\"\"Notify user that a prompt has been flagged.\"\"\" notify(state, \"error\", \"Prompt flagged as inappropriate.\") logging.info(f\"Prompt flagged as inappropriate: {prompt}\") def error_too_many_requests(state): \"\"\"Notify user that too many requests have been made.\"\"\" notify( state, \"error\", \"Too many requests. Please wait a few seconds before generating another text or image.\", ) logging.info(f\"Session request limit reached: {state.n_requests}\") state.n_requests = 1 # Define functions def generate_text(state): \"\"\"Generate Tweet text.\"\"\" state.tweet = \"\" state.image = None # Check the number of requests done by the user if state.n_requests >= 5: error_too_many_requests(state) return # Check if the user has put a topic if state.topic == \"\": notify(state, \"error\", \"Please enter a topic\") return # Create the prompt and add a style or not if state.style == \"\": state.prompt = ( f\"Write a {state.mood}Tweet about {state.topic} in less than 120 characters \" f\"and with the style of {state.style}:\\n\\n\\n\\n\" ) else: state.prompt = f\"Write a {state.mood}Tweet about {state.topic} in less than 120 characters:\\n\\n\" # openai configured and check if text is flagged openai = oai.Openai() flagged = openai.moderate(state.prompt) if flagged: error_prompt_flagged(state, f\"Prompt: {state.prompt}\\n\") return else: # Generate the tweet state.n_requests += 1 state.tweet = openai.complete(state.prompt).strip().replace('\"', \"\") # Notify the user in console and in the GUI logging.info( f\"Topic: {state.prompt}{state.mood}{state.style}\\n\" f\"Tweet: {state.tweet}\" ) notify(state, \"success\", \"Tweet created!\") def generate_image(state): \"\"\"Generate Tweet image.\"\"\" notify(state, \"info\", \"Generating image...\") # Check the number of requests done by the user if state.n_requests >= 5: error_too_many_requests(state) return state.image = None # Creates the prompt prompt_wo_hashtags = re.sub(\"#[A-Za-z0-9_]+\", \"\", state.prompt) processing_prompt = ( \"Create a detailed but brief description of an image that captures \" f\"the essence of the following text:\\n{prompt_wo_hashtags}\\n\\n\" ) # Openai configured and check if text is flagged openai = oai.Openai() flagged = openai.moderate(processing_prompt) if flagged: error_prompt_flagged(state, processing_prompt) return else: state.n_requests += 1 # Generate the prompt that will create the image processed_prompt = ( openai.complete(prompt=processing_prompt, temperature=0.5, max_tokens=40) .strip() .replace('\"', \"\") .split(\".\")[0] + \".\" ) # Generate the image state.image = openai.image(processed_prompt) # Notify the user in console and in the GUI logging.info(f\"Tweet: {state.prompt}\\nImage prompt: {processed_prompt}\") notify(state, \"success\", f\"Image created!\") def feeling_lucky(state): \"\"\"Generate a feeling-lucky tweet.\"\"\" with open(\"moods.txt\") as f: sample_moods = f.read().splitlines() state.topic = \"an interesting topic\" state.mood = random.choice(sample_moods) state.style = \"\" generate_text(state) # Variables tweet = \"\" prompt = \"\" n_requests = 0 topic = \"AI\" mood = \"inspirational\" style = \"elonmusk\" image = None # Called whever there is a problem def on_exception(state, function_name: str, ex: Exception): logging.error(f\"Problem {ex} \\nin {function_name}\") notify(state, \"error\", f\"Problem {ex} \\nin {function_name}\") def update_documents(state: taipy.gui.state, docs: list[dict]) -> None: \"\"\" Updates a partial with a list of documents Args: state: The state of the GUI docs: A list of documents \"\"\" updated_part = \"\" for doc in docs: title = doc[\"title\"] summary = doc[\"summary\"] link = doc[\"link\"] updated_part += f\"\"\"
\"\"\" state.p.update_content(state, updated_part) # Markdown for the entire page ## ## \"text\" here is just a name given to my part/my section ## it has no meaning in the code page = \"\"\" <|container| # **Generate**{: .color-primary} Tweets This mini-app generates Tweets using OpenAI's GPT-3 based [Davinci model](https://beta.openai.com/docs/models/overview) for texts and [DALL\u00b7E](https://beta.openai.com/docs/guides/images) for images. You can find the code on [GitHub](https://github.com/Avaiga/demo-tweet-generation) and the original author on [Twitter](https://twitter.com/kinosal).
<|layout|columns=1 1 1|gap=30px|class_name=card| |topic> |mood> |style> Create a Generate text button <|Generate text|button|on_action=generate_text|label=Generate text|> <|Feeling lucky|button|on_action=feeling_lucky|label=Feeling Lucky|> |> --- ### Generated **Tweet**{: .color-primary} Create a text input for the tweet <|{tweet}|input|multiline|label=Resulting tweet|class_name=fullwidth|>
<|Generate image|button|on_action=generate_image|label=Generate image|active={prompt!=\"\" and tweet!=\"\"}|>
<|{image}|image|height=400px|> |image> Break line **Code from [@kinosal](https://twitter.com/kinosal)** Original code can be found [here](https://github.com/kinosal/tweet) |> \"\"\" if __name__ == \"__main__\": Gui(page).run(dark_mode=False, port=5089) "}
+{"text": "# Create app for py2jsonl3.py py2jsonl3.py\nimport os\nimport json\n\nEXCLUDED_FILES = [\"CODE_OF_CONDUCT.md\", \"CONTRIBUTING.md\", \"INSTALLATION.md\", \"README.md\"]\n\ndef find_files(directory, extensions):\n for root, dirs, files in os.walk(directory):\n for file in files:\n if file.endswith(extensions) and file not in EXCLUDED_FILES:\n yield os.path.join(root, file)\n\ndef extract_content(file_path):\n with open(file_path, 'r', encoding='utf-8') as file:\n return file.read()\n\ndef write_to_jsonl(output_file, data):\n with open(output_file, 'a', encoding='utf-8') as file:\n json_record = json.dumps(data)\n file.write(json_record + '\\n')\n\ndef main(directory, output_file):\n for file_path in find_files(directory, ('.py', '.md')):\n file_content = extract_content(file_path)\n file_comment = f\"# Create app for {os.path.basename(file_path)}\"\n data = {\"text\": file_comment + '\\n' + file_content}\n write_to_jsonl(output_file, data)\n\ndirectory = 'taipy_repos3' # Replace with the path to your directory\noutput_file = 'output.jsonl' # Name of the output JSONL file\n\nmain(directory, output_file)\n"}
+{"text": "# Create app for demo-remove-background main.py\nfrom taipy.gui import Gui, notify\nfrom rembg import remove\nfrom PIL import Image\nfrom io import BytesIO\n\n\npath_upload = \"\"\npath_download = \"fixed_img.png\"\noriginal_image = None\nfixed_image = None\nfixed = False\n\n\npage = \"\"\"<|toggle|theme|>\n\n\nUpload and download\n<|{path_upload}|file_selector|on_action=fix_image|extensions=.png,.jpg|label=Upload original image|>\n\n \nDownload it here\n<|{path_download}|file_download|label=Download fixed image|active={fixed}|>\n|>\n\n<|container|\n# Image Background **Eliminator**{: .color-primary}\n\n\ud83d\udc36 Give it a try by uploading an image to witness the seamless removal of the background. You can download images in full quality from the sidebar.\nThis code is open source and accessible on [GitHub](https://github.com/Avaiga/demo-remove-background).\n \n\n\n\n|col1>\n\n\n|col2>\n|images>\n\n|>\n|page>\n\"\"\"\n\n\ndef convert_image(img):\n buf = BytesIO()\n img.save(buf, format=\"PNG\")\n byte_im = buf.getvalue()\n return byte_im\n\n\ndef fix_image(state):\n notify(state, 'info', 'Uploading original image...')\n image = Image.open(state.path_upload)\n \n notify(state, 'info', 'Removing the background...')\n fixed_image = remove(image)\n fixed_image.save(\"fixed_img.png\")\n\n notify(state, 'success', 'Background removed successfully!')\n state.original_image = convert_image(image)\n state.fixed_image = convert_image(fixed_image)\n state.fixed = True\n\nif __name__ == \"__main__\":\n Gui(page=page).run(margin=\"0px\", title='Background Remover')\n"}
+{"text": "# Create app for demo-tweet-generation oai.py\n\"\"\"OpenAI API connector.\"\"\"\n\n# Import from standard library\nimport os\nimport logging\n\n# Import from 3rd party libraries\nimport openai\n\nimport os\n\n# Assign credentials from environment variable or streamlit secrets dict\nopenai.api_key = \"Enter your token here\"\n\n# Suppress openai request/response logging\n# Handle by manually changing the respective APIRequestor methods in the openai package\n# Does not work hosted on Streamlit since all packages are re-installed by Poetry\n# Alternatively (affects all messages from this logger):\nlogging.getLogger(\"openai\").setLevel(logging.WARNING)\n\n\nclass Openai:\n \"\"\"OpenAI Connector.\"\"\"\n\n @staticmethod\n def moderate(prompt: str) -> bool:\n \"\"\"Call OpenAI GPT Moderation with text prompt.\n Args:\n prompt: text prompt\n Return: boolean if flagged\n \"\"\"\n try:\n response = openai.Moderation.create(prompt)\n return response[\"results\"][0][\"flagged\"]\n\n except Exception as e:\n logging.error(f\"OpenAI API error: {e}\")\n\n @staticmethod\n def complete(prompt: str, temperature: float = 0.9, max_tokens: int = 50) -> str:\n \"\"\"Call OpenAI GPT Completion with text prompt.\n Args:\n prompt: text prompt\n Return: predicted response text\n \"\"\"\n kwargs = {\n \"engine\": \"text-davinci-003\",\n \"prompt\": prompt,\n \"temperature\": temperature,\n \"max_tokens\": max_tokens,\n \"top_p\": 1, # default\n \"frequency_penalty\": 0, # default,\n \"presence_penalty\": 0, # default\n }\n try:\n response = openai.Completion.create(**kwargs)\n return response[\"choices\"][0][\"text\"]\n\n except Exception as e:\n logging.error(f\"OpenAI API error: {e}\")\n\n @staticmethod\n def image(prompt: str) -> str:\n \"\"\"Call OpenAI Image Create with text prompt.\n Args:\n prompt: text prompt\n Return: image url\n \"\"\"\n try:\n response = openai.Image.create(\n prompt=prompt,\n n=1,\n size=\"512x512\",\n response_format=\"url\",\n )\n return response[\"data\"][0][\"url\"]\n\n except Exception as e:\n logging.error(f\"OpenAI API error: {e}\")"}
+{"text": "# Create app for demo-tweet-generation main.py\n# Import from standard library\nimport logging\nimport random\nimport re\n\n# Import from 3rd party libraries\nfrom taipy.gui import Gui, notify\n\n# Import modules\nimport oai\n\n# Configure logger\nlogging.basicConfig(format=\"\\n%(asctime)s\\n%(message)s\", level=logging.INFO, force=True)\n\n\ndef error_prompt_flagged(state, prompt):\n \"\"\"Notify user that a prompt has been flagged.\"\"\"\n notify(state, \"error\", \"Prompt flagged as inappropriate.\")\n logging.info(f\"Prompt flagged as inappropriate: {prompt}\")\n\ndef error_too_many_requests(state):\n \"\"\"Notify user that too many requests have been made.\"\"\"\n notify(state, \"error\", \"Too many requests. Please wait a few seconds before generating another text or image.\")\n logging.info(f\"Session request limit reached: {state.n_requests}\")\n state.n_requests = 1\n\n\n# Define functions\ndef generate_text(state):\n \"\"\"Generate Tweet text.\"\"\"\n state.tweet = \"\"\n state.image = None\n\n # Check the number of requests done by the user\n if state.n_requests >= 5:\n error_too_many_requests(state)\n return\n\n # Check if the user has put a topic\n if state.topic == \"\":\n notify(state, \"error\", \"Please enter a topic\")\n return\n\n # Create the prompt and add a style or not\n if state.style == \"\":\n state.prompt = (\n f\"Write a {state.mood}Tweet about {state.topic} in less than 120 characters \"\n f\"and with the style of {state.style}:\\n\\n\\n\\n\"\n )\n else:\n state.prompt = f\"Write a {state.mood}Tweet about {state.topic} in less than 120 characters:\\n\\n\"\n\n\n # openai configured and check if text is flagged\n openai = oai.Openai()\n flagged = openai.moderate(state.prompt)\n \n if flagged:\n error_prompt_flagged(state, f\"Prompt: {state.prompt}\\n\")\n return\n else:\n # Generate the tweet\n state.n_requests += 1\n state.tweet = (\n openai.complete(state.prompt).strip().replace('\"', \"\")\n )\n\n # Notify the user in console and in the GUI\n logging.info(\n f\"Topic: {state.prompt}{state.mood}{state.style}\\n\"\n f\"Tweet: {state.tweet}\"\n )\n notify(state, \"success\", \"Tweet created!\")\n\n\ndef generate_image(state):\n \"\"\"Generate Tweet image.\"\"\"\n notify(state, \"info\", \"Generating image...\")\n\n # Check the number of requests done by the user\n if state.n_requests >= 5:\n error_too_many_requests(state)\n return\n\n state.image = None\n\n # Creates the prompt\n prompt_wo_hashtags = re.sub(\"#[A-Za-z0-9_]+\", \"\", state.prompt)\n processing_prompt = (\n \"Create a detailed but brief description of an image that captures \"\n f\"the essence of the following text:\\n{prompt_wo_hashtags}\\n\\n\"\n )\n\n # Openai configured and check if text is flagged\n openai = oai.Openai()\n flagged = openai.moderate(processing_prompt)\n\n if flagged:\n error_prompt_flagged(state, processing_prompt)\n return\n else:\n state.n_requests += 1\n # Generate the prompt that will create the image\n processed_prompt = (\n openai.complete(\n prompt=processing_prompt, temperature=0.5, max_tokens=40\n )\n .strip()\n .replace('\"', \"\")\n .split(\".\")[0]\n + \".\"\n )\n\n # Generate the image\n state.image = openai.image(processed_prompt)\n\n # Notify the user in console and in the GUI\n logging.info(f\"Tweet: {state.prompt}\\nImage prompt: {processed_prompt}\")\n notify(state, \"success\", f\"Image created!\")\n\n\n\n\n# Variables\ntweet = \"\"\nprompt = \"\"\nn_requests = 0\n\ntopic = \"AI\"\nmood = \"inspirational\"\nstyle = \"elonmusk\"\n\nimage = None\n\n# Called whever there is a problem\ndef on_exception(state, function_name: str, ex: Exception):\n logging.error(f\"Problem {ex} \\nin {function_name}\")\n notify(state, 'error', f\"Problem {ex} \\nin {function_name}\")\n\n\n# Markdown for the entire page\n## \n## \"text\" here is just a name given to my part/my section\n## it has no meaning in the code\npage = \"\"\"\n<|container|\n# **Generate**{: .color-primary} Tweets\n\nThis mini-app generates Tweets using OpenAI's GPT-3 based [Davinci model](https://beta.openai.com/docs/models/overview) for texts and [DALL\u00b7E](https://beta.openai.com/docs/guides/images) for images. You can find the code on [GitHub](https://github.com/Avaiga/demo-tweet-generation) and the original author on [Twitter](https://twitter.com/kinosal).\n\n \n\n<|layout|columns=1 1 1|gap=30px|class_name=card|\n\n|topic>\n\n\n|mood>\n\n\n|style>\n\n<|Generate text|button|on_action=generate_text|label=Generate text|>\n|>\n\n \n\n---\n\n \n\n### Generated **Tweet**{: .color-primary}\n\n<|{tweet}|input|multiline|label=Resulting tweet|class_name=fullwidth|>\n\n
<|Generate image|button|on_action=generate_image|label=Generate image|active={prompt!=\"\" and tweet!=\"\"}|>
\n\n<|{image}|image|height=400px|>\n|image>\n\n \n\n**Code from [@kinosal](https://twitter.com/kinosal)**\n\nOriginal code can be found [here](https://github.com/kinosal/tweet)\n|>\n\"\"\"\n\n\nif __name__ == \"__main__\":\n Gui(page).run(title='Tweet Generation')\n"}
+{"text": "# Create app for demo-realtime-pollution sender.py\n# echo-client.py\n\nimport math\nimport time\nimport socket\nimport pickle\nimport numpy as np\n\nHOST = \"127.0.0.1\"\nPORT = 65432\n\ninit_lat = 49.247\ninit_long = 1.377\n\nfactory_lat = 49.246\nfactory_long = 1.369\n\ndiff_lat = abs(init_lat - factory_lat) * 15\ndiff_long = abs(init_long - factory_long) * 15\n\nlats_unique = np.arange(init_lat - diff_lat, init_lat + diff_lat, 0.001)\nlongs_unique = np.arange(init_long - diff_long, init_long + diff_long, 0.001)\n\ncountdown = 20\n\n\ndef pollution(lat: float, long: float):\n \"\"\"\n Return pollution level in percentage\n Pollution should be centered around the factory\n Pollution should decrease with distance to factory\n Pollution should have an added random component\n\n Args:\n - lat: latitude\n - long: longitude\n\n Returns:\n - pollution level\n \"\"\"\n global countdown\n return 80 * (0.5 + 0.5 * math.sin(countdown / 20)) * math.exp(\n -(0.8 * (lat - factory_lat) ** 2 + 0.2 * (long - factory_long) ** 2) / 0.00005\n ) + np.random.randint(0, 50)\n\n\nlats = []\nlongs = []\npollutions = []\n\nfor lat in lats_unique:\n for long in longs_unique:\n lats.append(lat)\n longs.append(long)\n pollutions.append(pollution(lat, long))\n\n\ndef update():\n \"\"\"\n Update the pollution levels\n \"\"\"\n for i, _ in enumerate(lats):\n pollutions[i] = pollution(lats[i], longs[i])\n return pollutions\n\n\nwith socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:\n s.connect((HOST, PORT))\n while True:\n data = pickle.dumps(pollutions)\n s.sendall(data)\n print(f\"Sent Data: {pollutions[:5]}\")\n pollutions = update()\n countdown += 5\n time.sleep(5)\n"}
+{"text": "# Create app for demo-realtime-pollution receiver.py\nimport socket\nimport pickle\nimport math\nfrom threading import Thread\nfrom taipy.gui import Gui, State, invoke_callback, get_state_id\nimport numpy as np\nimport pandas as pd\n\ninit_lat = 49.247\ninit_long = 1.377\n\nfactory_lat = 49.246\nfactory_long = 1.369\n\ndiff_lat = abs(init_lat - factory_lat) * 15\ndiff_long = abs(init_long - factory_long) * 15\n\nlats_unique = np.arange(init_lat - diff_lat, init_lat + diff_lat, 0.001)\nlongs_unique = np.arange(init_long - diff_long, init_long + diff_long, 0.001)\n\ncountdown = 20\nperiods = 0\nline_data = pd.DataFrame({\"Time\": [], \"Max AQI\": []})\n\ndrone_data = pd.DataFrame(\n {\n \"Drone ID\": [43, 234, 32, 23, 5, 323, 12, 238, 21, 84],\n \"Battery Level\": [\n \"86%\",\n \"56%\",\n \"45%\",\n \"12%\",\n \"85%\",\n \"67%\",\n \"34%\",\n \"78%\",\n \"90%\",\n \"100%\",\n ],\n \"AQI\": [40, 34, 24, 22, 33, 45, 23, 34, 23, 34],\n \"Status\": [\n \"Moving\",\n \"Measuring\",\n \"Measuring\",\n \"Stopped\",\n \"Measuring\",\n \"Moving\",\n \"Moving\",\n \"Measuring\",\n \"Measuring\",\n \"Measuring\",\n ],\n }\n)\n\nHOST = \"127.0.0.1\"\nPORT = 65432\n\nlayout_map = {\n \"mapbox\": {\n \"style\": \"open-street-map\",\n \"center\": {\"lat\": init_lat, \"lon\": init_long},\n \"zoom\": 13,\n },\n \"dragmode\": \"false\",\n \"margin\": {\"l\": 0, \"r\": 0, \"b\": 0, \"t\": 0},\n}\n\nlayout_line = {\n \"title\": \"Max Measured AQI over Time\",\n \"yaxis\": {\"range\": [0, 150]},\n}\n\noptions = {\n \"opacity\": 0.8,\n \"colorscale\": \"Bluered\",\n \"zmin\": 0,\n \"zmax\": 140,\n \"colorbar\": {\"title\": \"AQI\"},\n \"hoverinfo\": \"none\",\n}\n\nconfig = {\"scrollZoom\": False, \"displayModeBar\": False}\n\n\ndef pollution(lat: float, long: float):\n \"\"\"\n Return pollution level in percentage\n Pollution should be centered around the factory\n Pollution should decrease with distance to factory\n Pollution should have an added random component\n\n Args:\n - lat: latitude\n - long: longitude\n\n Returns:\n - pollution level\n \"\"\"\n global countdown\n return 80 * (0.5 + 0.5 * math.sin(countdown / 20)) * math.exp(\n -(0.8 * (lat - factory_lat) ** 2 + 0.2 * (long - factory_long) ** 2) / 0.00005\n ) + np.random.randint(0, 50)\n\n\nlats = []\nlongs = []\npollutions = []\ntimes = []\nmax_pollutions = []\n\nfor lat in lats_unique:\n for long in longs_unique:\n lats.append(lat)\n longs.append(long)\n pollutions.append(pollution(lat, long))\n\ndata_province_displayed = pd.DataFrame(\n {\n \"Latitude\": lats,\n \"Longitude\": longs,\n \"Pollution\": pollutions,\n }\n)\n\nmax_pollution = data_province_displayed[\"Pollution\"].max()\n\n\n# Socket handler\ndef client_handler(gui: Gui, state_id_list: list):\n s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n s.bind((HOST, PORT))\n s.listen()\n conn, _ = s.accept()\n while True:\n if data := conn.recv(1024 * 1024):\n pollutions = pickle.loads(data)\n print(f\"Data received: {pollutions[:5]}\")\n if hasattr(gui, \"_server\") and state_id_list:\n invoke_callback(\n gui,\n state_id_list[0],\n update_pollutions,\n [pollutions],\n )\n else:\n print(\"Connection closed\")\n break\n\n\n# Gui declaration\nstate_id_list = []\n\nGui.add_shared_variable(\"pollutions\")\n\n\ndef on_init(state: State):\n state_id = get_state_id(state)\n if (state_id := get_state_id(state)) is not None and state_id != \"\":\n state_id_list.append(state_id)\n update_pollutions(state, pollutions)\n\n\ndef update_pollutions(state: State, val):\n state.pollutions = val\n state.data_province_displayed = pd.DataFrame(\n {\n \"Latitude\": lats,\n \"Longitude\": longs,\n \"Pollution\": state.pollutions,\n }\n )\n # Add an hour to the time\n state.periods = state.periods + 1\n state.max_pollutions = state.max_pollutions + [max(state.pollutions)]\n state.times = pd.date_range(\n \"2020-11-04\", periods=len(state.max_pollutions), freq=\"H\"\n )\n state.line_data = pd.DataFrame(\n {\n \"Time\": state.times,\n \"Max AQI\": state.max_pollutions,\n }\n )\n\n\npage = \"\"\"\n<|{data_province_displayed}|chart|type=densitymapbox|plot_config={config}|options={options}|lat=Latitude|lon=Longitude|layout={layout_map}|z=Pollution|mode=markers|class_name=map|height=40vh|>\n<|layout|columns=1 2 2|\n<|part|class_name=card|\n**Max Measured AQI:**
\n<|{int(data_province_displayed[\"Pollution\"].mean())}|indicator|value={int(data_province_displayed[\"Pollution\"].mean())}|min=140|max=0|>\n|>\n\n<|part|class_name=card|\n<|{drone_data}|table|show_all=True|>\n|>\n\n<|part|class_name=card|\n<|{line_data[-30:]}|chart|type=lines|x=Time|y=Max AQI|layout={layout_line}|height=40vh|>\n|>\n|>\n\"\"\"\ngui = Gui(page=page)\n\nt = Thread(\n target=client_handler,\n args=(\n gui,\n state_id_list,\n ),\n)\nt.start()\ngui.run(run_browser=False)\n"}
+{"text": "# Create app for demo-pyspark-penguin-app config.py\n### app/config.py\nimport datetime as dt\nimport os\nimport subprocess\nimport sys\nfrom pathlib import Path\n\nimport pandas as pd\nimport taipy as tp\nfrom taipy import Config\n\nSCRIPT_DIR = Path(__file__).parent\nSPARK_APP_PATH = SCRIPT_DIR / \"penguin_spark_app.py\"\n\n\ninput_csv_path = str(SCRIPT_DIR / \"penguins.csv\")\n\n# -------------------- Data Nodes --------------------\n\ninput_csv_path_cfg = Config.configure_data_node(id=\"input_csv_path\", default_data=input_csv_path)\n# Path to save the csv output of the spark app\noutput_csv_path_cfg = Config.configure_data_node(id=\"output_csv_path\")\n\nprocessed_penguin_df_cfg = Config.configure_parquet_data_node(\n id=\"processed_penguin_df\", validity_period=dt.timedelta(days=1)\n)\n\nspecies_cfg = Config.configure_data_node(id=\"species\") # \"Adelie\", \"Chinstrap\", \"Gentoo\"\nisland_cfg = Config.configure_data_node(id=\"island\") # \"Biscoe\", \"Dream\", \"Torgersen\"\nsex_cfg = Config.configure_data_node(id=\"sex\") # \"male\", \"female\"\n\noutput_cfg = Config.configure_json_data_node(\n id=\"output\",\n)\n\n# -------------------- Tasks --------------------\n\n\ndef spark_process(input_csv_path: str, output_csv_path: str) -> pd.DataFrame:\n proc = subprocess.Popen(\n [\n str(Path(sys.executable).with_name(\"spark-submit\")),\n str(SPARK_APP_PATH),\n \"--input-csv-path\",\n input_csv_path,\n \"--output-csv-path\",\n output_csv_path,\n ],\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE,\n )\n\n try:\n outs, errs = proc.communicate(timeout=15)\n except subprocess.TimeoutExpired:\n proc.kill()\n outs, errs = proc.communicate()\n\n if proc.returncode != os.EX_OK:\n raise Exception(\"Spark training failed\")\n\n df = pd.read_csv(output_csv_path)\n\n return df\n\n\ndef filter(penguin_df: pd.DataFrame, species: str, island: str, sex: str) -> dict:\n df = penguin_df[(penguin_df.species == species) & (penguin_df.island == island) & (penguin_df.sex == sex)]\n output = df[[\"bill_length_mm\", \"bill_depth_mm\", \"flipper_length_mm\", \"body_mass_g\"]].to_dict(orient=\"records\")\n return output[0] if output else dict()\n\n\nspark_process_task_cfg = Config.configure_task(\n id=\"spark_process\",\n function=spark_process,\n skippable=True,\n input=[input_csv_path_cfg, output_csv_path_cfg],\n output=processed_penguin_df_cfg,\n)\n\nfilter_task_cfg = Config.configure_task(\n id=\"filter\",\n function=filter,\n skippable=True,\n input=[processed_penguin_df_cfg, species_cfg, island_cfg, sex_cfg],\n output=output_cfg,\n)\n\nscenario_cfg = Config.configure_scenario(\n id=\"scenario\", task_configs=[spark_process_task_cfg, filter_task_cfg]\n)\n"}
+{"text": "# Create app for demo-pyspark-penguin-app main.py\n### app/main.py\nfrom pathlib import Path\nfrom typing import Optional\n\nimport taipy as tp\nfrom config import scenario_cfg\nfrom taipy.gui import Gui, notify\n\n\nvalid_features: dict[str, list[str]] = {\n \"species\": [\"Adelie\", \"Chinstrap\", \"Gentoo\"],\n \"island\": [\"Torgersen\", \"Biscoe\", \"Dream\"],\n \"sex\": [\"Male\", \"Female\"],\n}\n\nselected_species = valid_features[\"species\"][0]\nselected_island = valid_features[\"island\"][0]\nselected_sex = valid_features[\"sex\"][0]\n\nselected_scenario: Optional[tp.Scenario] = None\n\ndata_dir = Path(__file__).with_name(\"data\")\ndata_dir.mkdir(exist_ok=True)\n\n\ndef scenario_on_creation(state, id, payload):\n _ = payload[\"config\"]\n date = payload[\"date\"]\n label = payload[\"label\"]\n properties = payload[\"properties\"]\n\n # Create scenario with selected configuration\n scenario = tp.create_scenario(scenario_cfg, creation_date=date, name=label)\n scenario.properties.update(properties)\n\n # Write the selected GUI values to the scenario\n scenario.species.write(state.selected_species)\n scenario.island.write(state.selected_island)\n scenario.sex.write(state.selected_sex.lower())\n output_csv_file = data_dir / f\"{scenario.id}.csv\"\n scenario.output_csv_path.write(str(output_csv_file))\n\n notify(state, \"S\", f\"Created {scenario.id}\")\n\n return scenario\n\n\ndef scenario_on_submission_change(state, submittable, details):\n \"\"\"When the selected_scenario's submission status changes, reassign selected_scenario to force a GUI refresh.\"\"\"\n\n state.selected_scenario = submittable\n\n\nselected_data_node = None\n\nmain_md = \"\"\"\n<|layout|columns=1 4|gap=1.5rem|\n\n\n\n----------\n\n## Scenario info\n\n<|{selected_scenario}|scenario|on_submission_change=scenario_on_submission_change|>\n\n|lhs>\n\n\n\n<|{selected_island}|selector|lov={valid_features[\"island\"]}|dropdown|label=Island|>\n\n<|{selected_sex}|selector|lov={valid_features[\"sex\"]}|dropdown|label=Sex|>\n\n|selections>\n\n----------\n\n## Output\n\n**<|{str(selected_scenario.output.read()) if selected_scenario and selected_scenario.output.is_ready_for_reading else 'Submit the scenario using the left panel.'}|text|raw|class_name=color-primary|>**\n\n## Data node inspector\n\n<|{selected_data_node}|data_node_selector|display_cycles=False|>\n\n**Data node value:**\n\n<|{str(selected_data_node.read()) if selected_data_node and selected_data_node.is_ready_for_reading else None}|>\n\n \n\n----------\n\n## DAG\n\n<|Scenario DAG|expandable|\n<|{selected_scenario}|scenario_dag|>\n|>\n\n|rhs>\n\n|>\n\"\"\"\n\n\ndef on_change(state, var_name: str, var_value):\n if var_name == \"selected_species\":\n state.selected_scenario.species.write(var_value)\n elif var_name == \"selected_island\":\n state.selected_scenario.island.write(var_value)\n elif var_name == \"selected_sex\":\n state.selected_scenario.sex.write(var_value.lower())\n\n\nif __name__ == \"__main__\":\n tp.Core().run()\n\n gui = Gui(main_md)\n gui.run(title=\"Spark with Taipy\")\n"}
+{"text": "# Create app for demo-pyspark-penguin-app penguin_spark_app.py\n### app/penguin_spark_app.py\nimport argparse\nimport os\nimport sys\n\nparser = argparse.ArgumentParser()\nparser.add_argument(\"--input-csv-path\", required=True, help=\"Path to the input penguin CSV file.\")\nparser.add_argument(\"--output-csv-path\", required=True, help=\"Path to save the output CSV file.\")\nargs = parser.parse_args()\n\nimport pyspark.pandas as ps\nfrom pyspark.sql import SparkSession\n\n\ndef read_penguin_df(csv_path: str):\n penguin_df = ps.read_csv(csv_path)\n return penguin_df\n\n\ndef clean(df: ps.DataFrame) -> ps.DataFrame:\n return df[df.sex.isin([\"male\", \"female\"])].dropna()\n\n\ndef process(df: ps.DataFrame) -> ps.DataFrame:\n \"\"\"The mean of measured penguin values, grouped by island and sex.\"\"\"\n\n mean_df = df.groupby(by=[\"species\", \"island\", \"sex\"]).agg(\"mean\").drop(columns=\"year\").reset_index()\n return mean_df\n\n\nif __name__ == \"__main__\":\n spark = SparkSession.builder.appName(\"Mean Penguin\").getOrCreate()\n\n penguin_df = read_penguin_df(args.input_csv_path)\n cleaned_penguin_df = clean(penguin_df)\n processed_penguin_df = process(cleaned_penguin_df)\n processed_penguin_df.to_pandas().to_csv(args.output_csv_path, index=False)\n\n sys.exit(os.EX_OK)\n"}
+{"text": "# Create app for demo-dask-customer-analysis config.py\nfrom taipy import Config\n\nfrom algos.algo import (\n preprocess_and_score,\n featurization_and_segmentation,\n segment_analysis,\n high_value_cust_summary_statistics,\n)\n\n# -------------------- Data Nodes --------------------\n\npath_to_data_cfg = Config.configure_data_node(id=\"path_to_data\", default_data=\"data/customers_data.csv\")\n\nscored_df_cfg = Config.configure_data_node(id=\"scored_df\")\n\npayment_threshold_cfg = Config.configure_data_node(id=\"payment_threshold\", default_data=1000)\n\nscore_threshold_cfg = Config.configure_data_node(id=\"score_threshold\", default_data=1.5)\n\nsegmented_customer_df_cfg = Config.configure_data_node(id=\"segmented_customer_df\")\n\nmetric_cfg = Config.configure_data_node(id=\"metric\", default_data=\"mean\")\n\nsegment_result_cfg = Config.configure_data_node(id=\"segment_result\")\n\nsummary_statistic_type_cfg = Config.configure_data_node(id=\"summary_statistic_type\", default_data=\"median\")\n\nhigh_value_summary_df_cfg = Config.configure_data_node(id=\"high_value_summary_df\")\n\n# -------------------- Tasks --------------------\n\npreprocess_and_score_task_cfg = Config.configure_task(\n id=\"preprocess_and_score\",\n function=preprocess_and_score,\n skippable=True,\n input=[path_to_data_cfg],\n output=[scored_df_cfg],\n)\n\nfeaturization_and_segmentation_task_cfg = Config.configure_task(\n id=\"featurization_and_segmentation\",\n function=featurization_and_segmentation,\n skippable=True,\n input=[scored_df_cfg, payment_threshold_cfg, score_threshold_cfg],\n output=[segmented_customer_df_cfg],\n)\n\nsegment_analysis_task_cfg = Config.configure_task(\n id=\"segment_analysis\",\n function=segment_analysis,\n skippable=True,\n input=[segmented_customer_df_cfg, metric_cfg],\n output=[segment_result_cfg],\n)\n\nhigh_value_cust_summary_statistics_task_cfg = Config.configure_task(\n id=\"high_value_cust_summary_statistics\",\n function=high_value_cust_summary_statistics,\n skippable=True,\n input=[segment_result_cfg, segmented_customer_df_cfg, summary_statistic_type_cfg],\n output=[high_value_summary_df_cfg],\n)\n\nscenario_cfg = Config.configure_scenario(\n id=\"scenario_1\",\n task_configs=[\n preprocess_and_score_task_cfg,\n featurization_and_segmentation_task_cfg,\n segment_analysis_task_cfg,\n high_value_cust_summary_statistics_task_cfg,\n ],\n)\n"}
+{"text": "# Create app for demo-dask-customer-analysis algo.py\nimport time\n\nimport dask.dataframe as dd\nimport pandas as pd\n\n\ndef preprocess_and_score(path_to_original_data: str):\n print(\"__________________________________________________________\")\n print(\"1. TASK 1: DATA PREPROCESSING AND CUSTOMER SCORING ...\")\n start_time = time.perf_counter() # Start the timer\n\n # Step 1: Read data using Dask\n df = dd.read_csv(path_to_original_data)\n\n # Step 2: Simplify the customer scoring formula\n df[\"CUSTOMER_SCORE\"] = (\n 0.5 * df[\"TotalPurchaseAmount\"] / 1000 + 0.3 * df[\"NumberOfPurchases\"] / 10 + 0.2 * df[\"AverageReviewScore\"]\n )\n\n # Save all customers to a new CSV file\n scored_df = df[[\"CUSTOMER_SCORE\", \"TotalPurchaseAmount\", \"NumberOfPurchases\", \"TotalPurchaseTime\"]]\n\n pd_df = scored_df.compute()\n\n end_time = time.perf_counter() # Stop the timer\n execution_time = (end_time - start_time) * 1000 # Calculate the time in milliseconds\n print(f\"Time of Execution: {execution_time:.4f} ms\")\n\n return pd_df\n\n\ndef featurization_and_segmentation(scored_df, payment_threshold, score_threshold):\n print(\"__________________________________________________________\")\n print(\"2. TASK 2: FEATURE ENGINEERING AND SEGMENTATION ...\")\n\n # payment_threshold, score_threshold = float(payment_threshold), float(score_threshold)\n start_time = time.perf_counter() # Start the timer\n\n df = scored_df\n\n # Feature: Indicator if customer's total purchase is above the payment threshold\n df[\"HighSpender\"] = (df[\"TotalPurchaseAmount\"] > payment_threshold).astype(int)\n\n # Feature: Average time between purchases\n df[\"AverageTimeBetweenPurchases\"] = df[\"TotalPurchaseTime\"] / df[\"NumberOfPurchases\"]\n\n # Additional computationally intensive features\n df[\"Interaction1\"] = df[\"TotalPurchaseAmount\"] * df[\"NumberOfPurchases\"]\n df[\"Interaction2\"] = df[\"TotalPurchaseTime\"] * df[\"CUSTOMER_SCORE\"]\n df[\"PolynomialFeature\"] = df[\"TotalPurchaseAmount\"] ** 2\n\n # Segment customers based on the score_threshold\n df[\"ValueSegment\"] = [\"High Value\" if score > score_threshold else \"Low Value\" for score in df[\"CUSTOMER_SCORE\"]]\n\n end_time = time.perf_counter() # Stop the timer\n execution_time = (end_time - start_time) * 1000 # Calculate the time in milliseconds\n print(f\"Time of Execution: {execution_time:.4f} ms\")\n\n return df\n\n\ndef segment_analysis(df: pd.DataFrame, metric):\n print(\"__________________________________________________________\")\n print(\"3. TASK 3: SEGMENT ANALYSIS ...\")\n start_time = time.perf_counter() # Start the timer\n\n # Detailed analysis for each segment: mean/median of various metrics\n segment_analysis = (\n df.groupby(\"ValueSegment\")\n .agg(\n {\n \"CUSTOMER_SCORE\": metric,\n \"TotalPurchaseAmount\": metric,\n \"NumberOfPurchases\": metric,\n \"TotalPurchaseTime\": metric,\n \"HighSpender\": \"sum\", # Total number of high spenders in each segment\n \"AverageTimeBetweenPurchases\": metric,\n }\n )\n .reset_index()\n )\n\n end_time = time.perf_counter() # Stop the timer\n execution_time = (end_time - start_time) * 1000 # Calculate the time in milliseconds\n print(f\"Time of Execution: {execution_time:.4f} ms\")\n\n return segment_analysis\n\n\ndef high_value_cust_summary_statistics(df: pd.DataFrame, segment_analysis: pd.DataFrame, summary_statistic_type: str):\n print(\"__________________________________________________________\")\n print(\"4. TASK 4: ADDITIONAL ANALYSIS BASED ON SEGMENT ANALYSIS ...\")\n start_time = time.perf_counter() # Start the timer\n\n # Filter out the High Value customers\n high_value_customers = df[df[\"ValueSegment\"] == \"High Value\"]\n\n # Use summary_statistic_type to calculate different types of summary statistics\n if summary_statistic_type == \"mean\":\n average_purchase_high_value = high_value_customers[\"TotalPurchaseAmount\"].mean()\n elif summary_statistic_type == \"median\":\n average_purchase_high_value = high_value_customers[\"TotalPurchaseAmount\"].median()\n elif summary_statistic_type == \"max\":\n average_purchase_high_value = high_value_customers[\"TotalPurchaseAmount\"].max()\n elif summary_statistic_type == \"min\":\n average_purchase_high_value = high_value_customers[\"TotalPurchaseAmount\"].min()\n\n median_score_high_value = high_value_customers[\"CUSTOMER_SCORE\"].median()\n\n # Fetch the summary statistic for 'TotalPurchaseAmount' for High Value customers from segment_analysis\n segment_statistic_high_value = segment_analysis.loc[\n segment_analysis[\"ValueSegment\"] == \"High Value\", \"TotalPurchaseAmount\"\n ].values[0]\n\n # Create a DataFrame to hold the results\n result_df = pd.DataFrame(\n {\n \"SummaryStatisticType\": [summary_statistic_type],\n \"AveragePurchaseHighValue\": [average_purchase_high_value],\n \"MedianScoreHighValue\": [median_score_high_value],\n \"SegmentAnalysisHighValue\": [segment_statistic_high_value],\n }\n )\n\n end_time = time.perf_counter() # Stop the timer\n execution_time = (end_time - start_time) * 1000 # Calculate the time in milliseconds\n print(f\"Time of Execution: {execution_time:.4f} ms\")\n\n return result_df\n\n\nif __name__ == \"__main__\":\n t1 = preprocess_and_score(\"data/customers_data.csv\")\n\n t2 = featurization_and_segmentation(t1, 1500, 1.5)\n\n t3 = segment_analysis(t2, \"mean\")\n\n t4 = high_value_cust_summary_statistics(t2, t3, \"mean\")\n\n print(t4)\n"}
+{"text": "# Create app for demo-taipy-gui-starter-1 main.py\nfrom taipy.gui import Gui\nfrom math import cos, exp \n\npage = \"\"\"\n#This is *Taipy* GUI \n\nA value: <|{decay}|>.\n\nA slider: \n<|{decay}|slider|>\n\nMy chart: \n<|{data}|chart|>\n\"\"\"\n\ndef compute_data(decay):\n return [cos(i/16) * exp(-i*decay/6000) for i in range(720)]\n\ndef on_change(state, var_name, var_value):\n if var_name == 'decay':\n state.data = compute_data(var_value)\n\ndecay = 10\ndata = compute_data(decay) \n\nGui(page=page).run(title='Taipy Demo GUI 1',\n \t\t dark_mode=False)"}
+{"text": "# Create app for demo-churn-classification main.py\nimport pandas as pd\nimport taipy as tp\nfrom taipy.gui import Gui, Icon, navigate\nfrom config.config import scenario_cfg\nfrom taipy.config import Config \nfrom pages.main_dialog import *\n\nimport warnings\nwith warnings.catch_warnings():\n warnings.simplefilter(action='ignore', category=FutureWarning)\n\n# Load configuration\nConfig.load('config/config.toml')\nscenario_cfg = Config.scenarios['churn_classification']\n\n# Execute the scenario\ntp.Core().run()\n\ndef create_first_scenario(scenario_cfg):\n \"\"\"Create and submit the first scenario.\"\"\"\n scenario = tp.create_scenario(scenario_cfg)\n tp.submit(scenario)\n return scenario\n\nscenario = create_first_scenario(scenario_cfg)\n\n# Read datasets\ntrain_dataset = scenario.train_dataset.read()\ntest_dataset = scenario.test_dataset.read()\nroc_dataset = scenario.roc_data_ml.read()\n\n# Process test dataset columns\ntest_dataset.columns = [str(column).upper() for column in test_dataset.columns]\n\n# Prepare data for visualization\nselect_x = test_dataset.drop('EXITED',axis=1).columns.tolist()\nx_selected = select_x[0]\nselect_y = select_x\ny_selected = select_y[1]\n\n# Read results and create charts\nvalues = scenario.results_ml.read()\nforecast_series = values['Forecast']\nscatter_dataset_pred = creation_scatter_dataset_pred(test_dataset, forecast_series)\nhisto_full_pred = creation_histo_full_pred(test_dataset, forecast_series)\nhisto_full = creation_histo_full(test_dataset)\nscatter_dataset = creation_scatter_dataset(test_dataset)\nfeatures_table = scenario.feature_importance_ml.read()\naccuracy_graph, f1_score_graph, score_auc_graph = compare_models_baseline(scenario, ['ml', 'baseline'])\n\ndef create_charts(model_type):\n \"\"\"Create pie charts and metrics for the given model type.\"\"\"\n metrics = c_update_metrics(scenario, model_type)\n (number_of_predictions, accuracy, f1_score, score_auc, \n number_of_good_predictions, number_of_false_predictions, \n fp_, tp_, fn_, tn_) = metrics\n \n pie_plotly = pd.DataFrame({\n \"values\": [number_of_good_predictions, number_of_false_predictions],\n \"labels\": [\"Correct predictions\", \"False predictions\"]\n })\n\n distrib_class = pd.DataFrame({\n \"values\": [len(values[values[\"Historical\"]==0]), len(values[values[\"Historical\"]==1])],\n \"labels\": [\"Stayed\", \"Exited\"]\n })\n\n score_table = pd.DataFrame({\n \"Score\": [\"Predicted stayed\", \"Predicted exited\"],\n \"Stayed\": [tn_, fp_],\n \"Exited\": [fn_, tp_]\n })\n\n pie_confusion_matrix = pd.DataFrame({\n \"values\": [tp_, tn_, fp_, fn_],\n \"labels\": [\"True Positive\", \"True Negative\", \"False Positive\", \"False Negative\"]\n })\n\n return (number_of_predictions, number_of_false_predictions, number_of_good_predictions, \n accuracy, f1_score, score_auc, pie_plotly, distrib_class, score_table, pie_confusion_matrix)\n\n# Initialize charts\nchart_metrics = create_charts('ml')\n(number_of_predictions, number_of_false_predictions, number_of_good_predictions, \n accuracy, f1_score, score_auc, pie_plotly, distrib_class, score_table, pie_confusion_matrix) = chart_metrics\n\ndef on_change(state, var_name, var_value):\n \"\"\"Handle variable changes in the GUI.\"\"\"\n if var_name in ['x_selected', 'y_selected']:\n update_histogram_and_scatter(state)\n elif var_name == 'mm_algorithm_selected':\n update_variables(state, var_value.lower())\n elif var_name in ['mm_algorithm_selected', 'db_table_selected']:\n handle_temp_csv_path(state)\n\n# GUI initialization\nmenu_lov = [\n (\"Data Visualization\", Icon('images/histogram_menu.svg', 'Data Visualization')),\n (\"Model Manager\", Icon('images/model.svg', 'Model Manager')),\n (\"Compare Models\", Icon('images/compare.svg', 'Compare Models')),\n ('Databases', Icon('images/Datanode.svg', 'Databases'))\n]\n\nroot_md = \"\"\"\n<|toggle|theme|>\n<|menu|label=Menu|lov={menu_lov}|on_action=menu_fct|>\n\"\"\"\n\npage = \"Data Visualization\"\n\ndef menu_fct(state, var_name, var_value):\n \"\"\"Function that is called when there is a change in the menu control.\"\"\"\n state.page = var_value['args'][0]\n navigate(state, state.page.replace(\" \", \"-\"))\n\ndef update_variables(state, model_type):\n \"\"\"Update the different variables and dataframes used in the application.\"\"\"\n global scenario\n state.values = scenario.data_nodes[f'results_{model_type}'].read()\n state.forecast_series = state.values['Forecast']\n \n metrics = c_update_metrics(scenario, model_type)\n (state.number_of_predictions, state.accuracy, state.f1_score, state.score_auc,\n number_of_good_predictions, number_of_false_predictions, fp_, tp_, fn_, tn_) = metrics\n \n update_charts(state, model_type, number_of_good_predictions, number_of_false_predictions, fp_, tp_, fn_, tn_)\n\ndef update_charts(state, model_type, number_of_good_predictions, number_of_false_predictions, fp_, tp_, fn_, tn_):\n \"\"\"This function updates all the charts of the GUI.\n\n Args:\n state: object containing all the variables used in the GUI\n model_type (str): the name of the model_type shown\n number_of_good_predictions (int): number of good predictions\n number_of_false_predictions (int): number of false predictions\n fp_ (float): false positive rate\n tp_ (float): true positive rate\n fn_ (float): false negative rate\n tn_ (float): true negative rate\n \"\"\"\n state.roc_dataset = scenario.data_nodes[f'roc_data_{model_type}'].read()\n state.features_table = scenario.data_nodes[f'feature_importance_{model_type}'].read()\n\n state.score_table = pd.DataFrame({\"Score\":[\"Predicted stayed\", \"Predicted exited\"],\n \"Stayed\": [tn_, fp_],\n \"Exited\" : [fn_, tp_]})\n\n state.pie_confusion_matrix = pd.DataFrame({\"values\": [tp_, tn_, fp_, fn_],\n \"labels\" : [\"True Positive\", \"True Negative\", \"False Positive\", \"False Negative\"]})\n\n state.scatter_dataset_pred = creation_scatter_dataset_pred(test_dataset, state.forecast_series)\n state.histo_full_pred = creation_histo_full_pred(test_dataset, state.forecast_series)\n \n # pie charts\n state.pie_plotly = pd.DataFrame({\"values\": [number_of_good_predictions, number_of_false_predictions],\n \"labels\": [\"Correct predictions\", \"False predictions\"]})\n\n state.distrib_class = pd.DataFrame({\"values\": [len(state.values[state.values[\"Historical\"]==0]),\n len(state.values[state.values[\"Historical\"]==1])],\n \"labels\" : [\"Stayed\", \"Exited\"]})\n\ndef on_init(state):\n update_histogram_and_scatter(state)\n\n# Define pages\npages = {\n \"/\": root_md + dialog_md,\n \"Data-Visualization\": dv_data_visualization_md,\n \"Model-Manager\": mm_model_manager_md, \n \"Compare-Models\": cm_compare_models_md,\n \"Databases\": db_databases_md,\n}\n\n# Run the GUI\nif __name__ == '__main__':\n gui = Gui(pages=pages)\n gui.run(title=\"Churn classification\", dark_mode=False, port=8494)\n"}
+{"text": "# Create app for demo-churn-classification config.py\nfrom algos.algos import *\nfrom taipy import Config, Scope\n##############################################################################################################################\n# Creation of the datanodes\n##############################################################################################################################\n# How to connect to the database\npath_to_csv = 'data/churn.csv'\n\n# path for csv and file_path for pickle\ninitial_dataset_cfg = Config.configure_data_node(id=\"initial_dataset\",\n path=path_to_csv,\n storage_type=\"csv\",\n has_header=True)\n\ndate_cfg = Config.configure_data_node(id=\"date\", default_data=\"None\")\n\npreprocessed_dataset_cfg = Config.configure_data_node(id=\"preprocessed_dataset\")\n\n# the final datanode that contains the processed data\ntrain_dataset_cfg = Config.configure_data_node(id=\"train_dataset\")\n\n# the final datanode that contains the processed data\ntrained_model_ml_cfg = Config.configure_data_node(id=\"trained_model_ml\")\ntrained_model_baseline_cfg= Config.configure_data_node(id=\"trained_model_baseline\")\n\n\n# the final datanode that contains the processed data\ntest_dataset_cfg = Config.configure_data_node(id=\"test_dataset\")\n\nforecast_dataset_ml_cfg = Config.configure_data_node(id=\"forecast_dataset_ml\")\nforecast_dataset_baseline_cfg = Config.configure_data_node(id=\"forecast_dataset_baseline\")\n\nroc_data_ml_cfg = Config.configure_data_node(id=\"roc_data_ml\")\nroc_data_baseline_cfg = Config.configure_data_node(id=\"roc_data_baseline\")\n\nscore_auc_ml_cfg = Config.configure_data_node(id=\"score_auc_ml\")\nscore_auc_baseline_cfg = Config.configure_data_node(id=\"score_auc_baseline\")\n\n\nmetrics_ml_cfg = Config.configure_data_node(id=\"metrics_ml\")\nmetrics_baseline_cfg = Config.configure_data_node(id=\"metrics_baseline\")\n\nfeature_importance_ml_cfg = Config.configure_data_node(id=\"feature_importance_ml\")\nfeature_importance_baseline_cfg = Config.configure_data_node(id=\"feature_importance_baseline\")\n\nresults_ml_cfg = Config.configure_data_node(id=\"results_ml\")\nresults_baseline_cfg = Config.configure_data_node(id=\"results_baseline\")\n\n\n##############################################################################################################################\n# Creation of the tasks\n##############################################################################################################################\n\n# the task will make the link between the input data node \n# and the output data node while executing the function\n\n# initial_dataset --> preprocess dataset --> preprocessed_dataset\ntask_preprocess_dataset_cfg = Config.configure_task(id=\"preprocess_dataset\",\n input=[initial_dataset_cfg,date_cfg],\n function=preprocess_dataset,\n output=preprocessed_dataset_cfg)\n\n# preprocessed_dataset --> create train data --> train_dataset, test_dataset\ntask_create_train_test_cfg = Config.configure_task(id=\"create_train_and_test_data\",\n input=preprocessed_dataset_cfg,\n function=create_train_test_data,\n output=[train_dataset_cfg, test_dataset_cfg])\n\n\n# train_dataset --> create train_model data --> trained_model\ntask_train_model_baseline_cfg = Config.configure_task(id=\"train_model_baseline\",\n input=train_dataset_cfg,\n function=train_model_baseline,\n output=[trained_model_baseline_cfg,feature_importance_baseline_cfg])\n \n# train_dataset --> create train_model data --> trained_model\ntask_train_model_ml_cfg = Config.configure_task(id=\"train_model_ml\",\n input=train_dataset_cfg,\n function=train_model_ml,\n output=[trained_model_ml_cfg,feature_importance_ml_cfg])\n \n\n# test_dataset --> forecast --> forecast_dataset\ntask_forecast_baseline_cfg = Config.configure_task(id=\"predict_the_test_data_baseline\",\n input=[test_dataset_cfg, trained_model_baseline_cfg],\n function=forecast,\n output=forecast_dataset_baseline_cfg)\n# test_dataset --> forecast --> forecast_dataset\ntask_forecast_ml_cfg = Config.configure_task(id=\"predict_the_test_data_ml\",\n input=[test_dataset_cfg, trained_model_ml_cfg],\n function=forecast,\n output=forecast_dataset_ml_cfg)\n\n\ntask_roc_ml_cfg = Config.configure_task(id=\"task_roc_ml\",\n input=[forecast_dataset_ml_cfg, test_dataset_cfg],\n function=roc_from_scratch,\n output=[roc_data_ml_cfg,score_auc_ml_cfg])\n\ntask_roc_baseline_cfg = Config.configure_task(id=\"task_roc_baseline\",\n input=[forecast_dataset_baseline_cfg, test_dataset_cfg],\n function=roc_from_scratch,\n output=[roc_data_baseline_cfg,score_auc_baseline_cfg])\n\n\ntask_create_metrics_baseline_cfg = Config.configure_task(id=\"task_create_metrics_baseline\",\n input=[forecast_dataset_baseline_cfg,test_dataset_cfg],\n function=create_metrics,\n output=metrics_baseline_cfg)\n\ntask_create_metrics_ml_cfg = Config.configure_task(id=\"task_create_metrics\",\n input=[forecast_dataset_ml_cfg,test_dataset_cfg],\n function=create_metrics,\n output=metrics_ml_cfg)\n\ntask_create_results_baseline_cfg = Config.configure_task(id=\"task_create_results_baseline\",\n input=[forecast_dataset_baseline_cfg,test_dataset_cfg],\n function=create_results,\n output=results_baseline_cfg)\n\ntask_create_results_ml_cfg = Config.configure_task(id=\"task_create_results_ml\",\n input=[forecast_dataset_ml_cfg,test_dataset_cfg],\n function=create_results,\n output=results_ml_cfg)\n\n\n##############################################################################################################################\n# Creation of the scenario\n##############################################################################################################################\n\nscenario_cfg = Config.configure_scenario(id=\"churn_classification\",\n task_configs=[task_create_metrics_baseline_cfg,\n task_create_metrics_ml_cfg,\n task_create_results_baseline_cfg,\n task_create_results_ml_cfg,\n task_forecast_baseline_cfg,\n task_forecast_ml_cfg,\n task_roc_ml_cfg,\n task_roc_baseline_cfg,\n task_train_model_baseline_cfg,\n task_train_model_ml_cfg,\n task_preprocess_dataset_cfg,\n task_create_train_test_cfg])\n\nConfig.export('config/config.toml')"}
+{"text": "# Create app for demo-churn-classification algos.py\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import roc_auc_score\n\nimport datetime as dt\n\nimport pandas as pd\nimport numpy as np\n\n##############################################################################################################################\n# Function used in the tasks\n##############################################################################################################################\n\ndef preprocess_dataset(initial_dataset: pd.DataFrame, date: dt.datetime=\"None\"):\n \"\"\"This function preprocess the dataset to be used in the model\n\n Args:\n initial_dataset (pd.DataFrame): the raw format when we first read the data\n\n Returns:\n pd.DataFrame: the preprocessed dataset for classification\n \"\"\"\n print(\"\\n Preprocessing the dataset...\")\n \n #We filter the dataframe on the date\n if date != \"None\":\n initial_dataset['Date'] = pd.to_datetime(initial_dataset['Date'])\n processed_dataset = initial_dataset[initial_dataset['Date'] <= date]\n print(len(processed_dataset))\n else:\n processed_dataset = initial_dataset\n \n processed_dataset = processed_dataset[['CreditScore','Geography','Gender','Age','Tenure','Balance','NumOfProducts','HasCrCard','IsActiveMember','EstimatedSalary','Exited']]\n \n \n processed_dataset = pd.get_dummies(processed_dataset)\n\n if 'Gender_Female' in processed_dataset.columns:\n processed_dataset.drop('Gender_Female',axis=1,inplace=True)\n \n processed_dataset = processed_dataset.apply(pd.to_numeric)\n \n columns_to_select = ['CreditScore', 'Age', 'Tenure', 'Balance', 'NumOfProducts', 'HasCrCard',\n 'IsActiveMember', 'EstimatedSalary', 'Geography_France', 'Geography_Germany',\n 'Geography_Spain', 'Gender_Male','Exited']\n \n processed_dataset = processed_dataset[[col for col in columns_to_select if col in processed_dataset.columns]]\n\n print(\" Preprocessing done!\\n\")\n return processed_dataset\n\n\ndef create_train_test_data(preprocessed_dataset: pd.DataFrame):\n \"\"\"This function will create the train data by segmenting the dataset\n\n Args:\n preprocessed_dataset (pd.DataFrame): the preprocessed dataset\n\n Returns:\n pd.DataFrame: the training dataset\n \"\"\"\n print(\"\\n Creating the training and testing dataset...\")\n \n X_train, X_test, y_train, y_test = train_test_split(preprocessed_dataset.iloc[:,:-1],preprocessed_dataset.iloc[:,-1],test_size=0.2,random_state=42)\n \n train_data = pd.concat([X_train,y_train],axis=1)\n test_data = pd.concat([X_test,y_test],axis=1)\n print(\" Creating done!\")\n return train_data, test_data\n\n\n\ndef train_model_baseline(train_dataset: pd.DataFrame):\n \"\"\"Function to train the Logistic Regression model\n\n Args:\n train_dataset (pd.DataFrame): the training dataset\n\n Returns:\n model (LogisticRegression): the fitted model\n \"\"\"\n print(\" Training the model...\\n\")\n X,y = train_dataset.iloc[:,:-1],train_dataset.iloc[:,-1]\n model_fitted = LogisticRegression().fit(X,y)\n print(\"\\n \",model_fitted,\" is trained!\")\n \n importance_dict = {'Features' : X.columns, 'Importance':model_fitted.coef_[0]}\n importance = pd.DataFrame(importance_dict).sort_values(by='Importance',ascending=True)\n return model_fitted, importance\n\ndef train_model_ml(train_dataset: pd.DataFrame):\n \"\"\"Function to train the Logistic Regression model\n\n Args:\n train_dataset (pd.DataFrame): the training dataset\n\n Returns:\n model (RandomForest): the fitted model\n \"\"\"\n print(\" Training the model...\\n\")\n X,y = train_dataset.iloc[:,:-1],train_dataset.iloc[:,-1]\n model_fitted = RandomForestClassifier().fit(X,y)\n print(\"\\n \",model_fitted,\" is trained!\")\n \n importance_dict = {'Features' : X.columns, 'Importance':model_fitted.feature_importances_}\n importance = pd.DataFrame(importance_dict).sort_values(by='Importance',ascending=True)\n return model_fitted, importance\n\ndef forecast(test_dataset: pd.DataFrame, trained_model: RandomForestClassifier):\n \"\"\"Function to forecast the test dataset\n\n Args:\n test_dataset (pd.DataFrame): the test dataset\n trained_model (LogisticRegression): the fitted model\n\n Returns:\n forecast (pd.DataFrame): the forecasted dataset\n \"\"\"\n print(\" Forecasting the test dataset...\")\n X,y = test_dataset.iloc[:,:-1],test_dataset.iloc[:,-1]\n #predictions = trained_model.predict(X)\n predictions = trained_model.predict_proba(X)[:, 1]\n print(\" Forecasting done!\")\n return predictions\n\n\ndef roc_from_scratch(probabilities, test_dataset, partitions=100):\n print(\" Calculation of the ROC curve...\")\n y_test = test_dataset.iloc[:,-1]\n \n roc = np.array([])\n for i in range(partitions + 1):\n threshold_vector = np.greater_equal(probabilities, i / partitions).astype(int)\n tpr, fpr = true_false_positive(threshold_vector, y_test)\n roc = np.append(roc, [fpr, tpr])\n \n roc_np = roc.reshape(-1, 2)\n roc_data = pd.DataFrame({\"False positive rate\": roc_np[:, 0], \"True positive rate\": roc_np[:, 1]})\n print(\" Calculation done\")\n print(\" Scoring...\")\n\n score_auc = roc_auc_score(y_test, probabilities)\n print(\" Scoring done\\n\")\n\n return roc_data, score_auc\n\n\ndef true_false_positive(threshold_vector:np.array, y_test:np.array):\n \"\"\"Function to calculate the true positive rate and the false positive rate\n \n Args:\n threshold_vector (np.array): the test dataset\n y_test (np.array): the fitted model\n\n Returns:\n tpr (pd.DataFrame): the forecasted dataset\n fpr (pd.DataFrame): the forecasted dataset\n \"\"\"\n \n true_positive = np.equal(threshold_vector, 1) & np.equal(y_test, 1)\n true_negative = np.equal(threshold_vector, 0) & np.equal(y_test, 0)\n false_positive = np.equal(threshold_vector, 1) & np.equal(y_test, 0)\n false_negative = np.equal(threshold_vector, 0) & np.equal(y_test, 1)\n\n tpr = true_positive.sum() / (true_positive.sum() + false_negative.sum())\n fpr = false_positive.sum() / (false_positive.sum() + true_negative.sum())\n\n return tpr, fpr\n\ndef create_metrics(predictions:np.array, test_dataset:np.array):\n print(\" Creating the metrics...\")\n threshold = 0.5\n threshold_vector = np.greater_equal(predictions, threshold).astype(int)\n \n y_test = test_dataset.iloc[:,-1]\n \n true_positive = (np.equal(threshold_vector, 1) & np.equal(y_test, 1)).sum()\n true_negative = (np.equal(threshold_vector, 0) & np.equal(y_test, 0)).sum()\n false_positive = (np.equal(threshold_vector, 1) & np.equal(y_test, 0)).sum()\n false_negative = (np.equal(threshold_vector, 0) & np.equal(y_test, 1)).sum()\n\n\n f1_score = np.around(2*true_positive/(2*true_positive+false_positive+false_negative), decimals=2)\n accuracy = np.around((true_positive+true_negative)/(true_positive+true_negative+false_positive+false_negative), decimals=2)\n dict_ftpn = {\"tp\": true_positive, \"tn\": true_negative, \"fp\": false_positive, \"fn\": false_negative}\n \n \n number_of_good_predictions = true_positive + true_negative\n number_of_false_predictions = false_positive + false_negative\n \n metrics = {\"f1_score\": f1_score,\n \"accuracy\": accuracy,\n \"dict_ftpn\": dict_ftpn,\n 'number_of_predictions': len(predictions),\n 'number_of_good_predictions':number_of_good_predictions,\n 'number_of_false_predictions':number_of_false_predictions}\n \n return metrics\n\n \ndef create_results(forecast_values,test_dataset):\n forecast_series_proba = pd.Series(np.around(forecast_values,decimals=2), index=test_dataset.index, name='Probability')\n forecast_series = pd.Series((forecast_values>0.5).astype(int), index=test_dataset.index, name='Forecast')\n true_series = pd.Series(test_dataset.iloc[:,-1], name=\"Historical\",index=test_dataset.index)\n index_series = pd.Series(range(len(true_series)), index=test_dataset.index, name=\"Id\")\n \n results = pd.concat([index_series, forecast_series_proba, forecast_series, true_series], axis=1)\n return results"}
+{"text": "# Create app for demo-churn-classification main_dialog.py\nfrom pages.compare_models_md import *\nfrom pages.data_visualization_md import *\nfrom pages.databases_md import *\nfrom pages.model_manager_md import *\n\ndr_show_roc = False\n\ndialog_md = \"\"\"\n<|dialog|open={dr_show_roc}|title=ROC Curve|on_action={lambda s: s.assign(\"dr_show_roc\", False)}|labels=Close|width=1000px|\n<|{roc_dataset}|chart|x=False positive rate|y[1]=True positive rate|label[1]=True positive rate|height=500px|width=900px|type=scatter|>\n|>\n\"\"\""}
+{"text": "# Create app for demo-churn-classification databases_md.py\nimport pathlib\n\n# This path is used to create a temporary CSV file download the table\ntempdir = pathlib.Path(\".tmp\")\ntempdir.mkdir(exist_ok=True)\nPATH_TO_TABLE = str(tempdir / \"table.csv\")\n\n# Selector to select the table to show\ndb_table_selector = ['Training Dataset', 'Test Dataset', 'Forecast Dataset', 'Confusion Matrix']\ndb_table_selected = db_table_selector[0]\n\ndef handle_temp_csv_path(state):\n \"\"\"This function checks if the temporary csv file exists. If it does, it is deleted. Then, the temporary csv file\n is created for the right table\n\n Args:\n state: object containing all the variables used in the GUI\n \"\"\"\n if state.db_table_selected == 'Test Dataset':\n state.test_dataset.to_csv(PATH_TO_TABLE, sep=';')\n if state.db_table_selected == 'Confusion Matrix':\n state.score_table.to_csv(PATH_TO_TABLE, sep=';')\n if state.db_table_selected == \"Training Dataset\":\n state.train_dataset.to_csv(PATH_TO_TABLE, sep=';')\n if state.db_table_selected == \"Forecast Dataset\":\n state.values.to_csv(PATH_TO_TABLE, sep=';')\n\n\n# Aggregation of the strings to create the complete page\ndb_databases_md = \"\"\"\n# Data**bases**{: .color-primary}\n\n<|layout|columns=2 2 1|\n<|{mm_algorithm_selected}|selector|lov={mm_algorithm_selector}|dropdown|label=Algorithm|active=False|>\n\n<|{db_table_selected}|selector|lov={db_table_selector}|dropdown|label=Table|>\n\n<|{PATH_TO_TABLE}|file_download|name=table.csv|label=Download table|>\n|>\n\n\n|Confusion>\n\n\n|Training>\n\n\n|Forecast>\n\n\n|test_dataset>\n\"\"\" \n\n"}
+{"text": "# Create app for demo-churn-classification data_visualization_md.py\nimport pandas as pd\nimport numpy as np\n\n\ndv_graph_selector = ['Histogram','Scatter']\ndv_graph_selected = dv_graph_selector[0]\n\n# Histograms dialog\nproperties_histo_full = {}\nproperties_scatter_dataset = {}\n\ndef creation_scatter_dataset(test_dataset:pd.DataFrame):\n \"\"\"This function creates the dataset for the scatter plot. For every column (except Exited), scatter_dataset will have a positive and negative version.\n The positive column will have NaN when the Exited is zero and the negative column will have NaN when the Exited is one.\n\n Args:\n test_dataset (pd.DataFrame): the test dataset\n\n Returns:\n pd.DataFrame: the datafram\n \"\"\"\n scatter_dataset = test_dataset.copy()\n\n for column in scatter_dataset.columns:\n if column != 'EXITED' :\n column_neg = str(column)+'_neg'\n column_pos = str(column)+'_pos'\n \n scatter_dataset[column_neg] = scatter_dataset[column]\n scatter_dataset[column_pos] = scatter_dataset[column]\n \n scatter_dataset.loc[(scatter_dataset['EXITED'] == 1),column_neg] = np.NaN\n scatter_dataset.loc[(scatter_dataset['EXITED'] == 0),column_pos] = np.NaN\n \n return scatter_dataset\n\n\ndef creation_histo_full(test_dataset:pd.DataFrame):\n \"\"\"This function creates the dataset for the histogram plot. For every column (except Exited), histo_full will have a positive and negative version.\n The positive column will have NaN when the Exited is zero and the negative column will have NaN when the Exited is one. \n\n Args:\n test_dataset (pd.DataFrame): the test dataset\n\n Returns:\n pd.DataFrame: the Dataframe used to display the Histogram\n \"\"\"\n histo_full = test_dataset.copy()\n \n for column in histo_full.columns:\n column_neg = str(column)+'_neg'\n histo_full[column_neg] = histo_full[column]\n histo_full.loc[(histo_full['EXITED'] == 1),column_neg] = np.NaN\n histo_full.loc[(histo_full['EXITED'] == 0),column] = np.NaN\n \n return histo_full\n\n\ndef update_histogram_and_scatter(state):\n global x_selected, y_selected\n x_selected = state.x_selected\n y_selected = state.y_selected\n state.properties_scatter_dataset = {\"x\":x_selected,\n \"y[1]\":y_selected+'_pos',\n \"y[2]\":y_selected+'_neg'} \n state.scatter_dataset = state.scatter_dataset\n state.scatter_dataset_pred = state.scatter_dataset_pred\n\n state.properties_histo_full = {\"x[1]\":x_selected,\n \"x[2]\":x_selected+'_neg'} \n state.histo_full = state.histo_full\n state.histo_full_pred = state.histo_full_pred\n\n\ndv_data_visualization_md = \"\"\"\n# Data **Visualization**{: .color-primary}\n<|{dv_graph_selected}|toggle|lov={dv_graph_selector}|>\n\n--------------------------------------------------------------------\n\n<|part|render={dv_graph_selected == 'Histogram'}|\n### Histogram\n<|{x_selected}|selector|lov={select_x}|dropdown=True|label=Select x|>\n\n<|{histo_full}|chart|type=histogram|properties={properties_histo_full}|rebuild|y=EXITED|label=EXITED|color[1]=red|color[2]=green|name[1]=Exited|name[2]=Stayed|height=600px|>\n|>\n\n<|part|render={dv_graph_selected == 'Scatter'}|\n### Scatter\n<|layout|columns= 1 2|\n<|{x_selected}|selector|lov={select_x}|dropdown|label=Select x|>\n\n<|{y_selected}|selector|lov={select_y}|dropdown|label=Select y|>\n|>\n\n<|{scatter_dataset}|chart|properties={properties_scatter_dataset}|rebuild|color[1]=red|color[2]=green|name[1]=Exited|name[2]=Stayed|mode=markers|type=scatter|height=600px|>\n|>\n\n\"\"\"\n\n"}
+{"text": "# Create app for demo-churn-classification compare_models_md.py\nimport numpy as np\n\nfrom sklearn.metrics import f1_score\n\nimport pandas as pd\nimport numpy as np\n\ncm_height_histo = \"100%\"\ncm_dict_barmode = {\"barmode\": \"stack\",\"margin\":{\"t\":30}}\ncm_options_md = \"height={cm_height_histo}|width={cm_height_histo}|layout={cm_dict_barmode}\"\n\ncm_compare_models_md = \"\"\"\n# Model comparison\n\n----\n\n \n \n \n\n<|layout|columns= 1 1 1|columns[mobile]=1|\n<|{accuracy_graph}|chart|type=bar|x=Model Type|y[1]=Accuracy Model|y[2]=Accuracy Baseline|title=Accuracy|\"\"\" + cm_options_md + \"\"\"|>\n\n<|{f1_score_graph}|chart|type=bar|x=Model Type|y[1]=F1 Score Model|y[2]=F1 Score Baseline|title=F1 Score|\"\"\" + cm_options_md + \"\"\"|>\n\n<|{score_auc_graph}|chart|type=bar|x=Model Type|y[1]=AUC Score Model|y[2]=AUC Score Baseline|title=AUC Score|\"\"\" + cm_options_md + \"\"\"|>\n\n|>\n\"\"\"\n\ndef compare_charts(accuracies, f1_scores, scores_auc, names):\n \"\"\"This funcion creates the pandas Dataframes (charts) used in the model comparison page\n\n Args:\n accuracies (list): list of accuracies\n f1_scores (list): list of f1 scores\n scores_auc (list): list of auc scores\n names (list): list of scenario names\n\n Returns:\n pd.DataFrame: the resulting three pd.DataFrame\n \"\"\"\n accuracy_graph = pd.DataFrame(create_metric_dict(accuracies, \"Accuracy\", names))\n f1_score_graph = pd.DataFrame(create_metric_dict(f1_scores, \"F1 Score\", names))\n score_auc_graph = pd.DataFrame(create_metric_dict(scores_auc, \"AUC Score\", names))\n\n return accuracy_graph, f1_score_graph, score_auc_graph\n\ndef compare_models_baseline(scenario,model_types):\n \"\"\"This function creates the objects for the model comparison\n\n Args:\n scenario (scenario): the selected scenario\n model_types (str): the name of the selected model type\n\n Returns:\n pd.DataFrame: the resulting three pd.DataFrame\n \"\"\"\n accuracies = []\n f1_scores = []\n scores_auc = []\n names = []\n for model_type in model_types:\n (_,accuracy,f1_score,score_auc,_,_,_,_,_,_) = c_update_metrics(scenario, model_type)\n \n accuracies.append(accuracy)\n f1_scores.append(f1_score)\n scores_auc.append(score_auc)\n names.append('Model' if model_type != \"baseline\" else \"Baseline\") \n \n accuracy_graph,f1_score_graph, score_auc_graph = compare_charts(accuracies, f1_scores, scores_auc, names)\n return accuracy_graph, f1_score_graph, score_auc_graph\n \n\ndef create_metric_dict(metric, metric_name, names):\n \"\"\"This function creates a dictionary of metrics for multiple models that will be used in a Dataframe shown on the Gui\n\n Args:\n metric (list): the value of the metric\n metric_name (str): the name of the metric\n names (list): list of scenario names\n\n Returns:\n dict: dicitonary used for a pandas Dataframe\n \"\"\"\n metric_dict = {}\n initial_list = [0]*len(names)\n \n metric_dict[\"Model Type\"] = names\n for i in range(len(names)):\n current_list = initial_list.copy()\n \n current_list[i] = metric[i]\n metric_dict[metric_name +\" \"+ names[i].capitalize()] = current_list\n \n return metric_dict\n\ndef c_update_metrics(scenario, model_type):\n \"\"\"This function updates the metrics of a scenario using a model\n\n Args:\n scenario (scenario): the selected scenario\n model_type (str): the name of the selected model_type\n\n Returns:\n obj: a number of values, lists that represent the metrics\n \"\"\"\n metrics = scenario.data_nodes[f'metrics_{model_type}'].read()\n\n number_of_predictions = metrics['number_of_predictions']\n number_of_good_predictions = metrics['number_of_good_predictions']\n number_of_false_predictions = metrics['number_of_false_predictions']\n\n accuracy = np.around(metrics['accuracy'], decimals=2)\n f1_score = np.around(metrics['f1_score'], decimals=2)\n score_auc = np.around(scenario.data_nodes[f'score_auc_{model_type}'].read(), decimals=2)\n \n dict_ftpn = metrics['dict_ftpn']\n \n fp_ = dict_ftpn['fp']\n tp_ = dict_ftpn['tp']\n fn_ = dict_ftpn['fn']\n tn_ = dict_ftpn['tn']\n return number_of_predictions, accuracy, f1_score, score_auc, number_of_good_predictions, number_of_false_predictions, fp_, tp_, fn_, tn_\n\n"}
+{"text": "# Create app for demo-churn-classification model_manager_md.py\nimport pandas as pd\nimport numpy as np\n\n\nmm_graph_selector_scenario = ['Metrics', 'Features', 'Histogram','Scatter']\nmm_graph_selected_scenario = mm_graph_selector_scenario[0]\n\nmm_algorithm_selector = ['Baseline', 'ML']\nmm_algorithm_selected = 'ML'\n\nmm_pie_color_dict_2 = {\"piecolorway\":[\"#00D08A\",\"#FE913C\"]}\nmm_pie_color_dict_4 = {\"piecolorway\":[\"#00D08A\",\"#81F1A0\",\"#F3C178\",\"#FE913C\"]}\n\nmm_margin_features = {'margin': {'l': 150}}\n\ndef creation_scatter_dataset_pred(test_dataset:pd.DataFrame, forecast_series:pd.Series):\n \"\"\"This function creates the dataset for the scatter plot for the predictions. For every column (except EXITED) will have a positive and negative version.\n EXITED is here a binary indicating if the prediction is good or bad.\n The positive column will have NaN when the Exited is zero and the negative column will have NaN when the Exited is one. \n\n Args:\n test_dataset (pd.DataFrame): the test dataset\n forecast_series (pd.DataFrame): the forecast dataset\n\n Returns:\n pd.DataFrame: the Dataframe used to display the Histogram\n \"\"\"\n \n scatter_dataset = test_dataset.copy()\n scatter_dataset['EXITED'] = (scatter_dataset['EXITED']!=forecast_series.to_numpy()).astype(int)\n\n for column in scatter_dataset.columns:\n if column != 'EXITED' :\n column_neg = str(column)+'_neg'\n column_pos = str(column)+'_pos'\n \n scatter_dataset[column_neg] = scatter_dataset[column]\n scatter_dataset[column_pos] = scatter_dataset[column]\n \n scatter_dataset.loc[(scatter_dataset['EXITED'] == 1),column_neg] = np.NaN\n scatter_dataset.loc[(scatter_dataset['EXITED'] == 0),column_pos] = np.NaN\n \n return scatter_dataset\n\n\n\n\ndef creation_histo_full_pred(test_dataset:pd.DataFrame,forecast_series:pd.Series):\n \"\"\"This function creates the dataset for the histogram plot for the predictions. For every column (except PREDICTION) will have a positive and negative version.\n PREDICTION is a binary indicating if the prediction is good or bad.\n The positive column will have NaN when the PREDICTION is zero and the negative column will have NaN when the PREDICTION is one. \n\n Args:\n test_dataset (pd.DataFrame): the test dataset\n forecast_series (pd.DataFrame): the forecast dataset\n\n Returns:\n pd.DataFrame: the Dataframe used to display the Histogram\n \"\"\"\n histo_full = test_dataset.copy()\n histo_full['EXITED'] = (histo_full['EXITED']!=forecast_series.to_numpy()).astype(int)\n histo_full.columns = histo_full.columns.str.replace('EXITED', 'PREDICTION')\n \n for column in histo_full.columns:\n column_neg = str(column)+'_neg'\n histo_full[column_neg] = histo_full[column]\n histo_full.loc[(histo_full['PREDICTION'] == 1),column_neg] = np.NaN\n histo_full.loc[(histo_full['PREDICTION'] == 0),column] = np.NaN\n \n return histo_full\n\n\n\nmm_model_manager_md = \"\"\"\n# **Model**{: .color-primary} Manager\n\n<|layout|columns=3 2 2 2|\n<|{mm_graph_selected_scenario}|toggle|lov={mm_graph_selector_scenario}|>\n\n\n<|{mm_algorithm_selected}|selector|lov={mm_algorithm_selector}|dropdown|label=Algorithm|>\n\n<|show roc|button|on_action={lambda s: s.assign(\"dr_show_roc\", True)}|>\n\n **Number of predictions:** <|{number_of_predictions}|>\n|>\n\n-----------------------------------------------------------------\n\n\n\n\n\n\n\n**Model accuracy**\n{: .text-center}\n\n<|{pie_plotly}|chart|title=Accuracy of predictions model|values=values|labels=labels|type=pie|layout={mm_pie_color_dict_2}|>\n|accuracy>\n\n\n\n**Model AUC**\n{: .text-center}\n\n<|{pie_confusion_matrix}|chart|title=Confusion Matrix|values=values|labels=labels|type=pie|layout={mm_pie_color_dict_4}|>\n|score_auc>\n\n\n\n**Model F1-score**\n{: .text-center}\n\n<|{distrib_class}|chart|title=Distribution between Exited and Stayed|values=values|labels=labels|type=pie|layout={mm_pie_color_dict_2}|>\n|f1_score>\n|>\n|Metrics>\n\n\n\n\n\n|Features>\n\n\n\n\n\n\n<|{histo_full_pred}|chart|type=histogram|properties={properties_histo_full}|rebuild|y=PREDICTION|label=PREDICTION|color[1]=red|color[2]=green|name[1]=Good Predictions|name[2]=Bad Predictions|height=600px|>\n|Histogram>\n\n\n\n\n\n\n\n\n<|{y_selected}|selector|lov={select_y}|dropdown=True|label=Select y|>\n|>\n\n<|{scatter_dataset_pred}|chart|properties={properties_scatter_dataset}|rebuild|color[1]=red|color[2]=green|name[1]=Bad prediction|name[2]=Good prediction|mode=markers|type=scatter|height=600px|>\n|Scatter>\n\"\"\"\n"}
+{"text": "# Create app for demo-stock-visualization main.py\nfrom taipy.gui import Gui, notify\nfrom datetime import date\nimport yfinance as yf\nfrom prophet import Prophet\nimport pandas as pd\n\n\n# Parameters for retrieving the stock data\nstart_date = \"2015-01-01\"\nend_date = date.today().strftime(\"%Y-%m-%d\")\nselected_stock = 'AAPL'\nn_years = 1\n\n\ndef get_stock_data(ticker, start, end):\n ticker_data = yf.download(ticker, start, end) # downloading the stock data from START to TODAY\n ticker_data.reset_index(inplace=True) # put date in the first column\n ticker_data['Date'] = pd.to_datetime(ticker_data['Date']).dt.tz_localize(None)\n return ticker_data\n\ndef get_data_from_range(state):\n print(\"GENERATING HIST DATA\")\n start_date = state.start_date if type(state.start_date)==str else state.start_date.strftime(\"%Y-%m-%d\")\n end_date = state.end_date if type(state.end_date)==str else state.end_date.strftime(\"%Y-%m-%d\")\n\n state.data = get_stock_data(state.selected_stock, start_date, end_date)\n if len(state.data) == 0:\n notify(state, \"error\", f\"Not able to download data {state.selected_stock} from {start_date} to {end_date}\")\n return\n notify(state, 's', 'Historical data has been updated!')\n notify(state, 'w', 'Deleting previous predictions...')\n state.forecast = pd.DataFrame(columns=['Date', 'Lower', 'Upper'])\n\n\n\ndef generate_forecast_data(data, n_years):\n # FORECASTING\n df_train = data[['Date', 'Close']]\n df_train = df_train.rename(columns={\"Date\": \"ds\", \"Close\": \"y\"}) # This is the format that Prophet accepts\n\n m = Prophet()\n m.fit(df_train)\n future = m.make_future_dataframe(periods=n_years * 365)\n fc = m.predict(future)[['ds', 'yhat_lower', 'yhat_upper']].rename(columns={\"ds\": \"Date\", \"yhat_lower\": \"Lower\", \"yhat_upper\": \"Upper\"})\n print(\"Process Completed!\")\n return fc\n\n\ndef forecast_display(state):\n notify(state, 'i', 'Predicting...')\n state.forecast = generate_forecast_data(state.data, state.n_years)\n notify(state, 's', 'Prediction done! Forecast data has been updated!')\n\n\n\n#### Getting the data, make initial forcast and build a front end web-app with Taipy GUI\ndata = get_stock_data(selected_stock, start_date, end_date)\nforecast = generate_forecast_data(data, n_years)\n\nshow_dialog = False\n\npartial_md = \"<|{forecast}|table|>\"\ndialog_md = \"<|{show_dialog}|dialog|partial={partial}|title=Forecast Data|on_action={lambda state: state.assign('show_dialog', False)}|>\"\n\npage = dialog_md + \"\"\"<|toggle|theme|>\n<|container|\n# Stock Price **Analysis**{: .color-primary} Dashboard\n\n<|layout|columns=1 2 1|gap=40px|class_name=card p2|\n\n \n\nTo:\n<|{end_date}|date|on_change=get_data_from_range|> \n|dates>\n\n \n\n\nor choose a popular one\n\n<|{selected_stock}|toggle|lov=MSFT;GOOG;AAPL; AMZN; META; COIN; AMC; PYPL|on_change=get_data_from_range|>\n|ticker>\n\n \n<|{n_years}|slider|min=1|max=5|> \n\n<|PREDICT|button|on_action=forecast_display|class_name={'plain' if len(forecast)==0 else ''}|>\n|years>\n\n|>\n\n\n<|Historical Data|expandable|expanded=False|\n<|layout|columns=1 1|\n<|\n### Historical **closing**{: .color-primary} price\n<|{data}|chart|mode=line|x=Date|y[1]=Open|y[2]=Close|>\n|>\n\n<|\n### Historical **daily**{: .color-primary} trading volume\n<|{data}|chart|mode=line|x=Date|y=Volume|>\n|>\n|>\n\n### **Whole**{: .color-primary} historical data: <|{selected_stock}|text|raw|>\n<|{data}|table|>\n\n \n|>\n\n\n### **Forecast**{: .color-primary} Data\n<|{forecast}|chart|mode=line|x=Date|y[1]=Lower|y[2]=Upper|>\n\n \n\n\n<|More info|button|on_action={lambda s: s.assign(\"show_dialog\", True)}|>\n{: .text-center}\n|>\n\n \n\"\"\"\n\n\n# Run Taipy GUI\ngui = Gui(page)\npartial = gui.add_partial(partial_md)\ngui.run(dark_mode=False, title=\"Stock Visualization\")\n"}
+{"text": "# Create app for demo-movie-genre main.py\nimport taipy as tp\nimport pandas as pd\nfrom taipy import Config, Scope, Gui\n\n# Create a Taipy App that will output the 7 best movies for a genre\n\n# Taipy Core - backend definition\n\n# Filter function for Task\ndef filtering_genre(initial_dataset: pd.DataFrame, selected_genre):\n filtered_dataset = initial_dataset[initial_dataset['genres'].str.contains(selected_genre)]\n filtered_data = filtered_dataset.nlargest(7, 'Popularity %')\n return filtered_data\n\n\n# Input Data Nodes configuration\ninitial_dataset_cfg = Config.configure_data_node(id=\"initial_dataset\",\n storage_type=\"csv\",\n path=\"data.csv\",\n scope=Scope.GLOBAL)\n\nselected_genre_cfg = Config.configure_data_node(id=\"selected_genre_node\",\n default_data=\"ACTION\",\n scope=Scope.GLOBAL)\n\n# Output Data Node configuration\nfiltered_data_cfg = Config.configure_data_node(id=\"filtered_data\",\n scope=Scope.GLOBAL)\n\n\n# Task configuration\nfilter_task_cfg = Config.configure_task(id=\"filter_genre\",\n function=filtering_genre,\n input=[initial_dataset_cfg, selected_genre_cfg],\n output=filtered_data_cfg,\n skippable=True)\n\n# Pipeline configuration\npipeline_cfg = Config.configure_pipeline(id=\"pipeline\",\n task_configs=[filter_task_cfg])\n# Scenario configuration\nscenario_cfg = Config.configure_scenario(id=\"scenario\", pipeline_configs=[pipeline_cfg])\n\n# Run of the Taipy Core service\ntp.Core().run()\n\n# Creation of my scenario\nscenario = tp.create_scenario(scenario_cfg)\n\n\n\n# Taipy GUI- front end definition\n\n# Callback definition\ndef modify_df(state):\n scenario.selected_genre_node.write(state.selected_genre)\n tp.submit(scenario)\n state.df = scenario.filtered_data.read() \n\n# Get list of genres\nlist_genres = ['Action', 'Adventure', 'Animation', 'Children', 'Comedy', 'Fantasy', 'IMAX', 'Romance',\n 'Sci-FI', 'Western', 'Crime', 'Mystery', 'Drama', 'Horror', 'Thriller', 'Film-Noir',\n 'War', 'Musical', 'Documentary']\n\n# Initialization of variables\ndf = pd.DataFrame(columns=['Title', 'Popularity %'])\nselected_genre = None\n\n# movie_genre_app\nmovie_genre_app = \"\"\"\n# Film recommendation\n\n## Choose your favorite genre\n<|{selected_genre}|selector|lov={list_genres}|on_change=modify_df|dropdown|>\n\n## Here are the top 7 picks\n<|{df}|chart|x=Title|y=Popularity %|type=bar|title=Film Popularity|>\n\"\"\"\n# run the app\nGui(page=movie_genre_app).run()\n"}
+{"text": "# Create app for demo-job-monitoring __init__.py\n"}
+{"text": "# Create app for demo-job-monitoring runtime.py\nfrom taipy import run\n\n\nclass App:\n \"\"\"A singleton class that provides the Taipy runtime objects.\"\"\"\n\n def __new__(cls):\n if not hasattr(cls, \"instance\"):\n cls.instance = super(App, cls).__new__(cls)\n return cls.instance\n\n @property\n def gui(self):\n return self.__gui\n\n @property\n def core(self):\n return self.__core\n\n @gui.setter\n def gui(self, gui):\n self.__gui = gui\n\n @core.setter\n def core(self, core):\n self.__core = core\n\n def start(self, **kwargs):\n # Starts the app by calling `taipy.run` on the core and gui objects:\n run(self.__gui, self.__core, **kwargs)\n"}
+{"text": "# Create app for demo-job-monitoring main.py\nfrom runtime import App\nfrom pages import root, monitoring\nimport taipy\nfrom taipy.config.config import Config\nfrom taipy.gui import Gui\nimport os\n\n# Variables for bindings\nall_jobs = [['','','','']]\nshow_dialog_run_pipeline = False\nselected_pipeline = None\nshow_details_pane = False\nselected_job = None\n\n\nif __name__ == \"__main__\":\n # Initialize Taipy objects\n Config.configure_job_executions(mode=\"standalone\", nb_of_workers=4)\n Config.load(\"app.config.toml\")\n App().core = taipy.Core()\n App().gui = Gui(pages={\"/\": root.page, \"monitoring\": monitoring.page})\n\n # Start the app\n App().start(\n title=\"Job Monitoring Demo\",\n port=os.environ.get(\"PORT\", \"8080\"),\n dark_mode=False,\n css_file=\"app\",\n )\n"}
+{"text": "# Create app for demo-job-monitoring __init__.py\n"}
+{"text": "# Create app for demo-job-monitoring ml.py\nfrom sklearn.linear_model import LogisticRegression\nimport pandas as pd\nimport numpy as np\n\n\n# Test prediction with a Female, 19 years old, earning 20000\nfixed_value = [1, 19, 20000]\n\n\ndef preprocess(df: pd.DataFrame) -> pd.DataFrame:\n def _gender_to_int(gender):\n if gender == \"Female\":\n return 1\n return 0\n\n df[\"GenderNum\"] = df[\"Gender\"].apply(_gender_to_int)\n\n return df\n\n\ndef train(dataset):\n # X (features) are \"GenderNum\", \"Age\", \"EstimatedSalary\"\n X = dataset[[\"GenderNum\", \"Age\", \"EstimatedSalary\"]]\n\n # Y is \"Purchased\"\n Y = dataset[[\"Purchased\"]]\n\n # Let's split the dataset: the first 50 will be used for training,\n # the rest will be for testing\n split = 50\n X_train, Y_train = X[:split], Y[:split]\n X_test, Y_test = X[split:], Y[split:]\n\n # Using scikit-learn default\n regression = LogisticRegression(random_state=0, max_iter=10000).fit(\n X_train.values, Y_train.values.ravel()\n )\n\n # Accuracy of our model:\n print(f\"intercept: {regression.intercept_} coefficients: {regression.coef_}\")\n print(f\"train accuracy: {regression.score(X_train, Y_train)}\")\n print(f\"test accuracy: {regression.score(X_test, Y_test)}\") # We aim for > 0.8...\n\n return regression\n\n\ndef predict(x, regression: LogisticRegression):\n variables = np.array(x).reshape(1, -1)\n result = regression.predict(variables)\n print(f\"for: {variables}, the prediction is {result}\")\n return result\n\n\nif __name__ == \"__main__\":\n # Testing\n df = pd.read_csv(\"data/data.csv\")\n df = preprocess(df)\n model = train(df)\n print(predict(fixed_value, model))\n"}
+{"text": "# Create app for demo-job-monitoring debug.py\nimport time\n\n\ndef long_running(anything):\n print(\"Waiting 20 seconds...\")\n time.sleep(20)\n print(\"Done!\")\n return anything\n\n\ndef raise_exception(anything):\n print(\"Waiting 5 seconds before raising an exception...\")\n time.sleep(5)\n raise Exception(\"A very expected error occured!\")\n"}
+{"text": "# Create app for demo-job-monitoring monitoring.py\nimport taipy as tp\nfrom taipy.gui import get_state_id, invoke_callback, Markdown\nfrom taipy.config.config import Config\nfrom taipy.core.job.job import Job\nfrom runtime import App\n\n\ndef get_all_jobs():\n \"\"\"Returns all the known jobs (as a array of fields).\"\"\"\n\n def _job_to_fields(job: Job) -> list[str]:\n return [\n job.submit_id,\n job.id,\n job.creation_date.strftime(\"%b %d %Y %H:%M:%S\"),\n str(job.status),\n ]\n\n return [_job_to_fields(job) for job in tp.get_jobs()]\n\n\ndef get_all_pipelines():\n \"\"\"Returns all pipelines (as an array of ids)\"\"\"\n return [\n pipeline.id\n for pipeline in Config.pipelines.values()\n if pipeline.id != \"default\" # we explicitely get rid of the \"default\" pipeline\n ]\n\n\ndef get_job_by_id(id):\n \"\"\"Return a job from its id\"\"\"\n found = [job for job in tp.get_jobs() if job.id == id]\n if found:\n return found[0]\n return None\n\n\ndef get_job_by_index(index):\n \"\"\"Return a job from its index\"\"\"\n all_jobs = tp.get_jobs()\n if len(all_jobs) > index:\n return all_jobs[index]\n return None\n\n\ndef get_status(job: Job):\n \"\"\"Get the status of the given job as string.\"\"\"\n if not job:\n return None\n return job.status.name.lower()\n\n\n# -----------------------------------------------------------------------------\n# Callbacks / UI function\n\ndef on_style(state, index, row):\n status_index = 3\n if 'RUNNING' in row[status_index]:\n return 'blue'\n if 'COMPLETED' in row[status_index]:\n return 'green'\n if 'BLOCKED' in row[status_index]:\n return 'orange'\n if 'FAILED' in row[status_index]:\n return 'red'\n\ndef refresh_job_list(state):\n \"\"\"Refresh the job list\"\"\"\n state.all_jobs = get_all_jobs()\n\n\ndef job_updated(state_id, pipeline, job):\n \"\"\"Callback called when a job has been updated.\"\"\"\n\n # invoke_callback allows to run a function with a GUI _state_.\n invoke_callback(App().gui, state_id, refresh_job_list, args=[])\n\n\ndef open_run_pipeline_dialog(state):\n \"\"\"Opens the 'Run pipeline...' dialog.\"\"\"\n state.show_dialog_run_pipeline = True\n\n\ndef close_run_pipeline_dialog(state):\n \"\"\"Closes the 'Run pipeline...' dialog.\"\"\"\n state.show_dialog_run_pipeline = False\n\n\ndef run_pipeline(state):\n \"\"\"Runs a pipeline action.\"\"\"\n\n # We need to pass the state ID so that it can be restored in the job_updated listener:\n state_id = get_state_id(state)\n\n # Get selected pipeline config:\n selected = state.selected_pipeline\n pipeline_config = Config.pipelines[selected]\n if not pipeline_config:\n raise Exception(f\"unknown pipeline config: {selected}\")\n\n # Close the dialog\n close_run_pipeline_dialog(state)\n\n pipeline = tp.create_pipeline(pipeline_config)\n tp.subscribe_pipeline(pipeline=pipeline, callback=job_updated, params=[state_id])\n tp.submit(pipeline)\n\n\ndef on_table_click(state, table, action, payload):\n job_index = payload[\"index\"]\n selected_job = get_job_by_index(job_index)\n state.selected_job = selected_job\n state.show_details_pane = True\n\n\ndef cancel_selected_job(state):\n job_id = state.selected_job.id\n tp.cancel_job(state.selected_job)\n state.show_details_pane = False\n refresh_job_list(state)\n state.selected_job = get_job_by_id(job_id)\n\n\ndef delete_selected_job(state):\n tp.delete_job(state.selected_job, force=True)\n state.show_details_pane = False\n refresh_job_list(state)\n\n\n# -----------------------------------------------------------------------------\n# UI Configuration\n\ncolumns = {\n \"0\": {\"title\": \"Submit ID\"},\n \"1\": {\"title\": \"Job ID\"},\n \"2\": {\"title\": \"Creation Date\"},\n \"3\": {\"title\": \"Status\"},\n}\n\n\n# -----------------------------------------------------------------------------\n# Page\n\n\npage = Markdown(\"job_monitoring/pages/monitoring.md\")\n"}
+{"text": "# Create app for demo-job-monitoring __init__.py\n"}
+{"text": "# Create app for demo-job-monitoring root.py\nfrom taipy.gui import Markdown\n\ncontent = \"\"\"\n# Job Monitoring Demo\n\"\"\"\n\npage = Markdown(content)\n"}
+{"text": "# Create app for demo-job-monitoring monitoring.md\n<|{all_jobs}|table|columns={columns}|width='100%'|on_action={on_table_click}|style=on_style|>\n<|Refresh List|button|on_action={refresh_job_list}|>\n<|Run Pipeline...|button|on_action={open_run_pipeline_dialog}|>\n\n<|{show_dialog_run_pipeline}|dialog|title=Run pipeline...|\n<|{selected_pipeline}|selector|lov={get_all_pipelines()}|>\n<|Run|button|on_action={run_pipeline}|>\n<|Cancel|button|on_action={close_run_pipeline_dialog}|>\n|>\n<|{show_details_pane}|pane|\n\n# Job Details <|Delete|button|on_action=delete_selected_job|> <|Cancel|button|on_action=cancel_selected_job|>\n\n<|layout|columns=1 1|\n<|part|class_name=card|\n## Task\n<|{selected_job.task.config_id}|>\n|>\n\n<|part|class_name=card|\n## Status\n<|{get_status(selected_job)}|>\n|>\n|>\n\n<|part|class_name=card|\n## ID\n<|{selected_job.id}|>\n|>\n\n<|part|class_name=card|\n## Submission ID\n<|{selected_job.submit_id}|>\n|>\n\n<|part|class_name=card|\n## Creation Date\n<|{selected_job.creation_date.strftime(\"%b %d %y %H:%M:%S\")}|>\n|>\n\n<|part|class_name=card|\n## Stacktrace\n<|{\"\\n\".join(selected_job.stacktrace)}|class_name=code|>\n|>\n\n----\n\n\n|>\n"}
+{"text": "# Create app for demo-fraud-detection charts.py\n\"\"\" Prepare data for charts \"\"\"\n\nimport pandas as pd\n\n\ndef gen_amt_data(transactions: pd.DataFrame) -> list:\n \"\"\"\n Create a list of amt values for fraudulent and non-fraudulent transactions\n\n Args:\n - transactions: the transactions dataframe\n\n Returns:\n - a list of two dictionaries containing the data for the two histograms\n \"\"\"\n amt_fraud = transactions[transactions[\"fraud\"]][\"amt\"]\n amt_no_fraud = transactions[~transactions[\"fraud\"]][\"amt\"]\n amt_data = [\n {\"Amount ($)\": list(amt_no_fraud)},\n {\"Amount ($)\": list(amt_fraud)},\n ]\n return amt_data\n\n\ndef gen_gender_data(transactions: pd.DataFrame) -> pd.DataFrame:\n \"\"\"\n Create a dataframe containing the percentage of fraudulent transactions\n per gender\n\n Args:\n - transactions: the transactions dataframe\n\n Returns:\n - the resulting dataframe\n \"\"\"\n male_fraud_percentage = len(\n transactions[transactions[\"fraud\"]].loc[transactions[\"gender\"] == \"M\"]\n ) / len(transactions[transactions[\"fraud\"]])\n female_fraud_percentage = 1 - male_fraud_percentage\n male_not_fraud_percentage = len(\n transactions[~transactions[\"fraud\"]].loc[transactions[\"gender\"] == \"M\"]\n ) / len(transactions[~transactions[\"fraud\"]])\n female_not_fraud_percentage = 1 - male_not_fraud_percentage\n\n gender_data = pd.DataFrame(\n {\n \"Fraudulence\": [\"Not Fraud\", \"Fraud\"],\n \"Male\": [male_not_fraud_percentage, male_fraud_percentage],\n \"Female\": [female_not_fraud_percentage, female_fraud_percentage],\n }\n )\n return gender_data\n\n\ndef gen_cat_data(transactions: pd.DataFrame) -> pd.DataFrame:\n \"\"\"\n Generates a dataframe with the percentage difference\n between fraudulent and non-fraudulent transactions per category\n\n Args:\n - transactions: the transactions dataframe\n\n Returns:\n - the resulting dataframe\n \"\"\"\n categories = transactions[\"category\"].unique()\n fraud_categories = [\n len(\n transactions[transactions[\"fraud\"]].loc[\n transactions[\"category\"] == category\n ]\n )\n for category in categories\n ]\n fraud_categories_norm = [\n category / len(transactions[transactions[\"fraud\"]])\n for category in fraud_categories\n ]\n not_fraud_categories = [\n len(\n transactions[~transactions[\"fraud\"]].loc[\n transactions[\"category\"] == category\n ]\n )\n for category in categories\n ]\n not_fraud_categories_norm = [\n category / len(transactions[~transactions[\"fraud\"]])\n for category in not_fraud_categories\n ]\n diff_categories = [\n fraud_categories_norm[i] - not_fraud_categories_norm[i]\n for i in range(len(categories))\n ]\n cat_data = pd.DataFrame(\n {\n \"Category\": categories,\n \"Difference\": diff_categories,\n }\n )\n\n cat_data = cat_data.sort_values(by=\"Difference\", ascending=False)\n return cat_data\n\n\ndef gen_age_data(transactions: pd.DataFrame) -> pd.DataFrame:\n \"\"\"\n Generates a dataframe with the percentage of fraudulent transactions\n per age\n\n Args:\n - transactions: the transactions dataframe\n\n Returns:\n - the resulting dataframe\n \"\"\"\n age = range(111)\n fraud_age = [\n len(transactions[transactions[\"fraud\"]].loc[transactions[\"age\"] == age])\n / len(transactions[transactions[\"fraud\"]])\n for age in age\n ]\n not_fraud_age = [\n len(transactions[~transactions[\"fraud\"]].loc[transactions[\"age\"] == age])\n / len(transactions[~transactions[\"fraud\"]])\n for age in age\n ]\n age_data = pd.DataFrame(\n {\n \"Age\": age,\n \"Fraud\": fraud_age,\n \"Not Fraud\": not_fraud_age,\n }\n )\n return age_data\n\n\ndef gen_hour_data(transactions: pd.DataFrame) -> pd.DataFrame:\n \"\"\"\n Generates a dataframe with the percentage of fraudulent transactions\n per hour\n\n Args:\n - transactions: the transactions dataframe\n\n Returns:\n - the resulting dataframe\n \"\"\"\n hours = range(1, 25)\n fraud_hours = [\n len(transactions[transactions[\"fraud\"]].loc[transactions[\"hour\"] == hour])\n / len(transactions[transactions[\"fraud\"]])\n for hour in hours\n ]\n not_fraud_hours = [\n len(transactions[~transactions[\"fraud\"]].loc[transactions[\"hour\"] == hour])\n / len(transactions[~transactions[\"fraud\"]])\n for hour in hours\n ]\n hour_data = pd.DataFrame(\n {\n \"Hour\": hours,\n \"Fraud\": fraud_hours,\n \"Not Fraud\": not_fraud_hours,\n }\n )\n return hour_data\n\n\ndef gen_day_data(transactions: pd.DataFrame) -> pd.DataFrame:\n \"\"\"\n Generates a dataframe with the percentage of fraudulent transactions\n per weekday\n\n Args:\n - transactions: the transactions dataframe\n\n Returns:\n - the resulting dataframe\n \"\"\"\n days = range(7)\n days_names = [\n \"Monday\",\n \"Tuesday\",\n \"Wednesday\",\n \"Thursday\",\n \"Friday\",\n \"Saturday\",\n \"Sunday\",\n ]\n fraud_days = [\n len(transactions[transactions[\"fraud\"]].loc[transactions[\"day\"] == day])\n / len(transactions[transactions[\"fraud\"]])\n for day in days\n ]\n not_fraud_days = [\n len(transactions[~transactions[\"fraud\"]].loc[transactions[\"day\"] == day])\n / len(transactions[~transactions[\"fraud\"]])\n for day in days\n ]\n day_data = pd.DataFrame(\n {\n \"Day\": days_names,\n \"Fraud\": fraud_days,\n \"Not Fraud\": not_fraud_days,\n }\n )\n return day_data\n\n\ndef gen_month_data(transactions: pd.DataFrame) -> pd.DataFrame:\n \"\"\"\n Generates a dataframe with the percentage of fraudulent transactions\n per month\n\n Args:\n - transactions: the transactions dataframe\n\n Returns:\n - the resulting dataframe\n \"\"\"\n months = range(1, 13)\n months_names = [\n \"January\",\n \"February\",\n \"March\",\n \"April\",\n \"May\",\n \"June\",\n \"July\",\n \"August\",\n \"September\",\n \"October\",\n \"November\",\n \"December\",\n ]\n fraud_months = [\n len(transactions[transactions[\"fraud\"]].loc[transactions[\"month\"] == month])\n / len(transactions[transactions[\"fraud\"]])\n for month in months\n ]\n not_fraud_months = [\n len(transactions[~transactions[\"fraud\"]].loc[transactions[\"month\"] == month])\n / len(transactions[~transactions[\"fraud\"]])\n for month in months\n ]\n month_data = pd.DataFrame(\n {\n \"Month\": months_names,\n \"Fraud\": fraud_months,\n \"Not Fraud\": not_fraud_months,\n }\n )\n return month_data\n"}
+{"text": "# Create app for demo-fraud-detection utils.py\n\"\"\" Data Manipulation and Callbacks \"\"\"\nimport datetime as dt\nimport numpy as np\nimport pandas as pd\nfrom taipy.gui import State, navigate, notify\nimport xgboost as xgb\nfrom shap import Explainer, Explanation\nfrom sklearn.metrics import confusion_matrix\n\ncolumn_names = [\n \"amt\",\n \"zip\",\n \"city_pop\",\n \"age\",\n \"hour\",\n \"day\",\n \"month\",\n \"category_food_dining\",\n \"category_gas_transport\",\n \"category_grocery_net\",\n \"category_grocery_pos\",\n \"category_health_fitness\",\n \"category_home\",\n \"category_kids_pets\",\n \"category_misc_net\",\n \"category_misc_pos\",\n \"category_personal_care\",\n \"category_shopping_net\",\n \"category_shopping_pos\",\n \"category_travel\",\n]\n\n\ndef explain_pred(state: State, _: str, payload: dict) -> None:\n \"\"\"\n When a transaction is selected in the table\n Explain the prediction using SHAP, update the waterfall chart\n\n Args:\n - state: the state of the app\n - payload: the payload of the event containing the index of the transaction\n \"\"\"\n idx = payload[\"index\"]\n exp = state.explaination[idx]\n\n feature_values = [-value for value in list(exp.values)]\n data_values = list(exp.data)\n\n for i, value in enumerate(data_values):\n if isinstance(value, float):\n value = round(value, 2)\n data_values[i] = value\n\n names = [f\"{name}: {value}\" for name, value in zip(column_names, data_values)]\n\n exp_data = pd.DataFrame({\"Feature\": names, \"Influence\": feature_values})\n exp_data[\"abs_importance\"] = exp_data[\"Influence\"].abs()\n exp_data = exp_data.sort_values(by=\"abs_importance\", ascending=False)\n exp_data = exp_data.drop(columns=[\"abs_importance\"])\n exp_data = exp_data[:5]\n state.exp_data = exp_data\n\n if state.transactions.iloc[idx][\"fraud\"]:\n state.fraud_text = \"Why is this transaction fraudulent?\"\n else:\n state.fraud_text = \"Why is this transaction not fraudulent?\"\n\n first = state.transactions.iloc[idx][\"first\"]\n last = state.transactions.iloc[idx][\"last\"]\n\n state.specific_transactions = state.transactions[\n (state.transactions[\"first\"] == first) & (state.transactions[\"last\"] == last)\n ]\n\n state.selected_transaction = state.transactions.loc[[idx]]\n\n state.selected_client = f\"{first} {last}\"\n\n navigate(state, \"Analysis\")\n\n\ndef generate_transactions(\n state: State,\n df: pd.DataFrame,\n model: xgb.XGBRegressor,\n threshold: float,\n start_date=\"2020-06-21\",\n end_date=\"2030-01-01\",\n) -> [pd.DataFrame, Explanation]:\n \"\"\"\n Generates a DataFrame of transactions with the fraud prediction\n\n Args:\n - state: the state of the app\n - df: the DataFrame containing the transactions\n - model: the model used to predict the fraud\n - threshold: the threshold used to determine if a transaction is fraudulent\n - start_date: the start date of the transactions\n - end_date: the end date of the transactions\n\n Returns:\n - a DataFrame of transactions with the fraud prediction\n \"\"\"\n start_date = str(start_date)\n end_date = str(end_date)\n start_date_dt = dt.datetime.strptime(start_date, \"%Y-%m-%d\")\n end_date_dt = dt.datetime.strptime(end_date, \"%Y-%m-%d\")\n # Make sure the dates are separated by at least one day\n if (end_date_dt - start_date_dt).days < 1:\n notify(state, \"error\", \"The start date must be before the end date\")\n raise Exception(\"The start date must be before the end date\")\n # Make sure that start_date is between 2020-06-21 and 2020-06-30\n if not (dt.datetime(2020, 6, 21) <= start_date_dt <= dt.datetime(2020, 6, 30)):\n notify(\n state, \"error\", \"The start date must be between 2020-06-21 and 2020-06-30\"\n )\n raise Exception(\"The start date must be between 2020-06-21 and 2020-06-30\")\n df[\"age\"] = dt.date.today().year - pd.to_datetime(df[\"dob\"]).dt.year\n df[\"hour\"] = pd.to_datetime(df[\"trans_date_trans_time\"]).dt.hour\n df[\"day\"] = pd.to_datetime(df[\"trans_date_trans_time\"]).dt.dayofweek\n df[\"month\"] = pd.to_datetime(df[\"trans_date_trans_time\"]).dt.month\n test = df[\n [\n \"category\",\n \"amt\",\n \"zip\",\n \"city_pop\",\n \"age\",\n \"hour\",\n \"day\",\n \"month\",\n \"is_fraud\",\n ]\n ]\n test = pd.get_dummies(test, drop_first=True)\n test = test[df[\"trans_date_trans_time\"].between(str(start_date), str(end_date))]\n\n X_test = test.drop(\"is_fraud\", axis=\"columns\")\n X_test_values = X_test.values\n\n transactions = df[\n df[\"trans_date_trans_time\"].between(str(start_date), str(end_date))\n ]\n raw_results = model.predict(X_test_values)\n results = [str(min(1, round(result, 2))) for result in raw_results]\n transactions.insert(0, \"fraud_value\", results)\n # Low if under 0.2, Medium if under 0.5, High if over 0.5\n results = [\"Low\" if float(result) < 0.2 else \"Medium\" for result in raw_results]\n for i, result in enumerate(results):\n if result == \"Medium\" and float(raw_results[i]) > 0.5:\n results[i] = \"High\"\n transactions.insert(0, \"fraud_confidence\", results)\n results = [float(result) > threshold for result in raw_results]\n transactions.insert(0, \"fraud\", results)\n\n explainer = Explainer(model)\n sv = explainer(X_test)\n explaination = Explanation(sv, sv.base_values, X_test, feature_names=X_test.columns)\n # Drop Unnamed: 0 column if it exists\n if \"Unnamed: 0\" in transactions.columns:\n transactions = transactions.drop(columns=[\"Unnamed: 0\"])\n return transactions, explaination\n\n\ndef update_threshold(state: State) -> None:\n \"\"\"\n Change the threshold used to determine if a transaction is fraudulent\n Generate the confusion matrix\n\n Args:\n - state: the state of the app\n \"\"\"\n threshold = float(state.threshold)\n results = [\n float(result) > threshold for result in state.transactions[\"fraud_value\"]\n ]\n state.transactions[\"fraud\"] = results\n state.transactions = state.transactions\n results = [\n float(result) > threshold\n for result in state.original_transactions[\"fraud_value\"]\n ]\n state.original_transactions[\"fraud\"] = results\n state.original_transactions = state.original_transactions\n y_pred = results\n y_true = state.original_transactions[\"is_fraud\"]\n cm = confusion_matrix(y_true, y_pred)\n cm = cm.astype(\"float\") / cm.sum(axis=1)[:, np.newaxis]\n tp, tn, fp, fn = cm[1][1], cm[0][0], cm[0][1], cm[1][0]\n\n dataset = state.original_transactions[:10000]\n state.true_positives = dataset[\n (dataset[\"is_fraud\"] == True) & (dataset[\"fraud\"] == True)\n ]\n state.true_negatives = dataset[\n (dataset[\"is_fraud\"] == False) & (dataset[\"fraud\"] == False)\n ]\n state.false_positives = dataset[\n (dataset[\"is_fraud\"] == False) & (dataset[\"fraud\"] == True)\n ]\n state.false_negatives = dataset[\n (dataset[\"is_fraud\"] == True) & (dataset[\"fraud\"] == False)\n ]\n\n data = {\n \"Values\": [\n [fn, tp],\n [tn, fp],\n ],\n \"Actual\": [\"Fraud\", \"Not Fraud\"],\n \"Predicted\": [\"Not Fraud\", \"Fraud\"],\n }\n\n layout = {\n \"annotations\": [],\n \"xaxis\": {\"ticks\": \"\", \"side\": \"top\"},\n \"yaxis\": {\"ticks\": \"\", \"ticksuffix\": \" \"},\n }\n\n predicted = data[\"Predicted\"]\n actuals = data[\"Actual\"]\n for actual, _ in enumerate(actuals):\n for pred, _ in enumerate(predicted):\n value = data[\"Values\"][actual][pred]\n annotation = {\n \"x\": predicted[pred],\n \"y\": actuals[actual],\n \"text\": f\"{str(round(value, 3)*100)[:4]}%\",\n \"font\": {\"color\": \"white\" if value < 0.5 else \"black\", \"size\": 30},\n \"showarrow\": False,\n }\n layout[\"annotations\"].append(annotation)\n\n state.confusion_data = data\n state.confusion_layout = layout\n update_table(state)\n return (\n state.true_positives,\n state.true_negatives,\n state.false_positives,\n state.false_negatives,\n )\n\n\ndef update_table(state: State) -> None:\n \"\"\"\n Updates the table of transactions displayed\n\n Args:\n - state: the state of the app\n \"\"\"\n if state.selected_table == \"True Positives\":\n state.displayed_table = state.true_positives\n elif state.selected_table == \"False Positives\":\n state.displayed_table = state.false_positives\n elif state.selected_table == \"True Negatives\":\n state.displayed_table = state.true_negatives\n elif state.selected_table == \"False Negatives\":\n state.displayed_table = state.false_negatives\n"}
+{"text": "# Create app for demo-fraud-detection main.py\n\"\"\" Fraud Detection App \"\"\"\nimport pickle\n\nimport numpy as np\nimport pandas as pd\nfrom taipy.gui import Gui, Icon, State, navigate, notify\n\nfrom utils import (\n explain_pred,\n generate_transactions,\n update_threshold,\n update_table,\n)\nfrom charts import *\n\nDATA_POINTS = 30000\nthreshold = \"0.5\"\nthreshold_lov = np.arange(0, 1, 0.01)\nconfusion_text = \"Confusion Matrix\"\nfraud_text = \"No row selected\"\nexp_data = pd.DataFrame({\"Feature\": [], \"Influence\": []})\n\ndf = pd.read_csv(\"data/fraud_data.csv\")\ndf[\"merchant\"] = df[\"merchant\"].str[6:]\nmodel = pickle.load(open(\"model.pkl\", \"rb\"))\ntransactions, explaination = generate_transactions(None, df, model, float(threshold))\noriginal_transactions = transactions\noriginal_explaination = explaination\nspecific_transactions = transactions\nselected_client = \"No client selected\"\nstart_date = \"2020-06-21\"\nend_date = \"2020-06-22\"\nselected_table = \"True Positives\"\ntrue_positives = None\nfalse_positives = None\ntrue_negatives = None\nfalse_negatives = None\ndisplayed_table = None\nselected_transaction = None\n\n\ndef fraud_style(_: State, index: int, values: list) -> str:\n \"\"\"\n Style the transactions table: red if fraudulent\n\n Args:\n - state: the state of the app\n - index: the index of the row\n\n Returns:\n - the style of the row\n \"\"\"\n if values[\"fraud_confidence\"] == \"High\":\n return \"red-row\"\n elif values[\"fraud_confidence\"] == \"Medium\":\n return \"orange-row\"\n return \"\"\n\n\namt_data = gen_amt_data(transactions)\ngender_data = gen_gender_data(transactions)\ncat_data = gen_cat_data(transactions)\nage_data = gen_age_data(transactions)\nhour_data = gen_hour_data(transactions)\nday_data = gen_day_data(transactions)\nmonth_data = gen_month_data(transactions)\n\ndf = df[:DATA_POINTS]\ntransactions = transactions[:DATA_POINTS]\n\n\nwaterfall_layout = {\n \"margin\": {\"b\": 150},\n}\n\namt_options = [\n {\n \"marker\": {\"color\": \"#4A4\", \"opacity\": 0.8},\n \"xbins\": {\"start\": 0, \"end\": 2000, \"size\": 10},\n \"histnorm\": \"probability\",\n },\n {\n \"marker\": {\"color\": \"#A33\", \"opacity\": 0.8, \"text\": \"Compare Data\"},\n \"xbins\": {\"start\": 0, \"end\": 2000, \"size\": 10},\n \"histnorm\": \"probability\",\n },\n]\n\namt_layout = {\n \"barmode\": \"overlay\",\n \"showlegend\": True,\n}\n\nconfusion_data = pd.DataFrame({\"Predicted\": [], \"Actual\": [], \"Values\": []})\nconfusion_layout = None\nconfusion_options = {\"colorscale\": \"YlOrRd\", \"displayModeBar\": False}\nconfusion_config = {\"scrollZoom\": False, \"displayModeBar\": False}\n\ntransactions = df\ntransactions = transactions.drop(\"Unnamed: 0\", axis=\"columns\")\n\n\ndef on_init(state: State) -> None:\n \"\"\"\n Generate the confusion matrix on start\n\n Args:\n - state: the state of the app\n \"\"\"\n update_transactions(state)\n state.displayed_table = state.true_positives\n (\n state.true_positives,\n state.true_negatives,\n state.false_positives,\n state.false_negatives,\n ) = update_threshold(state)\n update_table(state)\n\n\ndef update_transactions(state: State) -> None:\n \"\"\"\n Detects frauds in the selected time period\n\n Args:\n - state: the state of the app\n \"\"\"\n notify(state, \"info\", \"Predicting fraud...\")\n state.transactions, state.explaination = generate_transactions(\n state, df, model, float(state.threshold), state.start_date, state.end_date\n )\n state.transactions.reset_index(inplace=True)\n number_of_fraud = len(state.transactions[state.transactions[\"fraud\"] == True])\n notify(state, \"success\", f\"Predicted {number_of_fraud} fraudulent transactions\")\n\n\nmenu_lov = [\n (\"Transactions\", Icon(\"images/transactions.png\", \"Transactions\")),\n (\"Analysis\", Icon(\"images/analysis.png\", \"Analysis\")),\n (\"Fraud Distribution\", Icon(\"images/distribution.png\", \"Fraud Distribution\")),\n (\"Threshold Selection\", Icon(\"images/threshold.png\", \"Threshold Selection\")),\n]\n\npage = \"Transactions\"\n\n\ndef menu_fct(state, var_name, var_value):\n \"\"\"Function that is called when there is a change in the menu control.\"\"\"\n state.page = var_value[\"args\"][0]\n navigate(state, state.page.replace(\" \", \"-\"))\n\n\nROOT = \"\"\"\n<|menu|label=Menu|lov={menu_lov}|on_action=menu_fct|>\n\"\"\"\n\nTRANSACTIONS_PAGE = \"\"\"\n# List of **Transactions**{: .color-primary}\n\n--------------------------------------------------------------------\n\n## Select start and end date for a prediction\n<|layout|columns=1 1 3|\nStart Date: <|{start_date}|date|>\n\nEnd Date (excluding): <|{end_date}|date|>\n|>\n\n<|Detect Frauds|button|on_action=update_transactions|>\n\n## Select a transaction to explain the prediction\n\n<|{transactions}|table|on_action=explain_pred|style=fraud_style|filter|rebuild|>\n\"\"\"\n\nANALYSIS_PAGE = \"\"\"\n# Prediction **Analysis**{: .color-primary}\n\n--------------------------------------------------------------------\n\n<|layout|columns=2 3|\n<|card|\n## <|{fraud_text}|text|>\n<|{exp_data}|chart|type=waterfall|x=Feature|y=Influence|layout={waterfall_layout}|>\n|>\n\n<|\n## Selected Transaction:\n<|{selected_transaction}|table|show_all=True|rebuild||style=fraud_style|>\n## Transactions of client: **<|{selected_client}|text|raw|>**{: .color-primary}\n<|{specific_transactions}|table|style=fraud_style|filter|on_action=explain_pred|>\n|>\n|>\n\"\"\"\n\nCHART_PAGE = \"\"\"\n# Fraud **Distribution**{: .color-primary}\n\n--------------------------------------------------------------------\n\n## Charts of fraud distribution by feature\n\n<|{amt_data}|chart|type=histogram|title=Transaction Amount Distribution|color[2]=red|color[1]=green|name[2]=Fraud|name[1]=Not Fraud|options={amt_options}|layout={amt_layout}|>\n <|{gender_data}|chart|type=bar|x=Fraudulence|y[1]=Male|y[2]=Female|title=Distribution of Fraud by Gender|>\n <|{cat_data}|chart|type=bar|x=Category|y=Difference|orientation=v|title=Difference in Fraudulence by Category (Positive = Fraudulent)|>\n <|{hour_data}|chart|type=bar|x=Hour|y[1]=Not Fraud|y[2]=Fraud|title=Distribution of Fraud by Hour|>\n <|{day_data}|chart|type=bar|x=Day|y[1]=Not Fraud|y[2]=Fraud|title=Distribution of Fraud by Day|>\n\"\"\"\n\nTHRESHOLD_PAGE = \"\"\"\n# Threshold **Selection**{: .color-primary}\n\n--------------------------------------------------------------------\n\n## Select a threshold of confidence to filter the transactions\n<|{threshold}|slider|on_change=update_threshold|lov=0.05;0.1;0.15;0.2;0.25;0.3;0.35;0.4;0.45;0.5;0.55;0.6;0.65;0.7;0.75;0.8;0.85;0.9;0.95|>\n<|layout|columns=1 2|\n<|{confusion_data}|chart|type=heatmap|z=Values|x=Predicted|y=Actual|layout={confusion_layout}|options={confusion_options}|plot_config={confusion_config}|height=70vh|>\n\n<|card\n<|{selected_table}|selector|lov=True Positives;False Positives;True Negatives;False Negatives|on_change=update_table|dropdown=True|>\n<|{displayed_table}|table|style=fraud_style|filter|rebuild|>\n|>\n|>\n\"\"\"\n\npages = {\n \"/\": ROOT,\n \"Transactions\": TRANSACTIONS_PAGE,\n \"Analysis\": ANALYSIS_PAGE,\n \"Fraud-Distribution\": CHART_PAGE,\n \"Threshold-Selection\": THRESHOLD_PAGE,\n}\n\nGui(pages=pages).run(title=\"Fraud Detection Demo\", dark_mode=False, debug=True)\n"}
+{"text": "# Create app for dask_taipy_bigdata_DEMO algo.py\nimport time\nimport pandas as pd\nimport dask.dataframe as dd\n\ndef task1(path_to_original_data: str):\n print(\"__________________________________________________________\")\n print(\"1. TASK 1: DATA PREPROCESSING AND CUSTOMER SCORING ...\")\n start_time = time.perf_counter() # Start the timer\n \n # Step 1: Read data using Dask\n df = dd.read_csv(path_to_original_data)\n \n # Step 2: Simplify the customer scoring formula\n df['CUSTOMER_SCORE'] = (\n 0.5 * df['TotalPurchaseAmount'] / 1000 +\n 0.3 * df['NumberOfPurchases'] / 10 +\n 0.2 * df['AverageReviewScore']\n )\n \n # Save all customers to a new CSV file\n scored_df = df[[\"CUSTOMER_SCORE\", \"TotalPurchaseAmount\", \"NumberOfPurchases\", \"TotalPurchaseTime\"]]\n \n pd_df = scored_df.compute()\n\n end_time = time.perf_counter() # Stop the timer\n execution_time = (end_time - start_time) * 1000 # Calculate the time in milliseconds\n print(f\"Time of Execution: {execution_time:.4f} ms\")\n \n return pd_df\n\ndef task2(scored_df, payment_threshold, score_threshold):\n print(\"__________________________________________________________\")\n print(\"2. TASK 2: FEATURE ENGINEERING AND SEGMENTATION ...\")\n\n payment_threshold, score_threshold = float(payment_threshold), float(score_threshold)\n start_time = time.perf_counter() # Start the timer\n \n df = scored_df\n \n # Feature: Indicator if customer's total purchase is above the payment threshold\n df['HighSpender'] = (df['TotalPurchaseAmount'] > payment_threshold).astype(int)\n \n # Feature: Average time between purchases\n df['AverageTimeBetweenPurchases'] = df['TotalPurchaseTime'] / df['NumberOfPurchases']\n \n # Additional computationally intensive features\n df['Interaction1'] = df['TotalPurchaseAmount'] * df['NumberOfPurchases']\n df['Interaction2'] = df['TotalPurchaseTime'] * df['CUSTOMER_SCORE']\n df['PolynomialFeature'] = df['TotalPurchaseAmount'] ** 2\n \n # Segment customers based on the score_threshold\n df['ValueSegment'] = ['High Value' if score > score_threshold else 'Low Value' for score in df['CUSTOMER_SCORE']]\n \n end_time = time.perf_counter() # Stop the timer\n execution_time = (end_time - start_time) * 1000 # Calculate the time in milliseconds\n print(f\"Time of Execution: {execution_time:.4f} ms\")\n \n return df\n\ndef task3(df: pd.DataFrame, metric):\n print(\"__________________________________________________________\")\n print(\"3. TASK 3: SEGMENT ANALYSIS ...\")\n start_time = time.perf_counter() # Start the timer\n \n # Detailed analysis for each segment: mean/median of various metrics\n segment_analysis = df.groupby('ValueSegment').agg({\n 'CUSTOMER_SCORE': metric,\n 'TotalPurchaseAmount': metric,\n 'NumberOfPurchases': metric,\n 'TotalPurchaseTime': metric,\n 'HighSpender': 'sum', # Total number of high spenders in each segment\n 'AverageTimeBetweenPurchases': metric\n }).reset_index()\n \n end_time = time.perf_counter() # Stop the timer\n execution_time = (end_time - start_time) * 1000 # Calculate the time in milliseconds\n print(f\"Time of Execution: {execution_time:.4f} ms\")\n \n return segment_analysis\n\ndef task4(df: pd.DataFrame, segment_analysis: pd.DataFrame, summary_statistic_type: str):\n print(\"__________________________________________________________\")\n print(\"4. TASK 4: ADDITIONAL ANALYSIS BASED ON SEGMENT ANALYSIS ...\")\n start_time = time.perf_counter() # Start the timer\n\n # Filter out the High Value customers\n high_value_customers = df[df['ValueSegment'] == 'High Value']\n \n # Use summary_statistic_type to calculate different types of summary statistics\n if summary_statistic_type == 'mean':\n average_purchase_high_value = high_value_customers['TotalPurchaseAmount'].mean()\n elif summary_statistic_type == 'median':\n average_purchase_high_value = high_value_customers['TotalPurchaseAmount'].median()\n elif summary_statistic_type == 'max':\n average_purchase_high_value = high_value_customers['TotalPurchaseAmount'].max()\n elif summary_statistic_type == 'min':\n average_purchase_high_value = high_value_customers['TotalPurchaseAmount'].min()\n \n median_score_high_value = high_value_customers['CUSTOMER_SCORE'].median()\n \n # Fetch the summary statistic for 'TotalPurchaseAmount' for High Value customers from segment_analysis\n segment_statistic_high_value = segment_analysis.loc[segment_analysis['ValueSegment'] == 'High Value', 'TotalPurchaseAmount'].values[0]\n\n # Create a DataFrame to hold the results\n result_df = pd.DataFrame({\n 'SummaryStatisticType': [summary_statistic_type],\n 'AveragePurchaseHighValue': [average_purchase_high_value],\n 'MedianScoreHighValue': [median_score_high_value],\n 'SegmentAnalysisHighValue': [segment_statistic_high_value]\n })\n\n end_time = time.perf_counter() # Stop the timer\n execution_time = (end_time - start_time) * 1000 # Calculate the time in milliseconds\n print(f\"Time of Execution: {execution_time:.4f} ms\")\n\n return result_df\n\n\n\n\nif __name__ == \"__main__\":\n\n t1 = task1(\"data/SMALL_amazon_customers_data.csv\")\n\n t2 = task2(t1, 1500, 1.5)\n\n t3 = task3(t2, \"mean\")\n\n t4 = task4(t2, t3, \"mean\")\n\n\n\n print(t4)\n\n"}
+{"text": "# Create app for demo-image-classification-part-2 readme.md\n# Image Classification Part 2 Using Taipy Core\n\n## Usage\n- [Usage](#usage)\n- [Image Classification Part 2](#what-is-image-classification-part-2)\n- [Directory Structure](#directory-structure)\n- [License](#license)\n- [Installation](#installation)\n- [Contributing](#contributing)\n- [Code of conduct](#code-of-conduct)\n\n## What is Image Classification Part 2\n\nTaipy is a Python library for creating Business Applications. More information on our\n[website](https://www.taipy.io).\n\n[Image Classification Part 2](https://github.com/Avaiga/image-classification-part-2) is about how to use Taipy Core and Taipy Studio to efficiently create and manage Data and ML pipelines. \n\n### Demo Type\n- **Level**: Intermediate\n- **Topic**: Taipy-CORE\n- **Components/Controls**: \n - Taipy CORE: configs, Taipy Studio\n\n## How to run\n\nThis demo works with a Python version superior to 3.8. Install the dependencies of the *Pipfile* and run the *main.py*.\n\n## Introduction\nThe Demo is the second part of the Image Classification App using Taipy and Tensorflow, and it is recommended to watch the first part or go through the repo to understand the main functions and tasks. \n\nThe video on Youtubecovers using Taipy Core and Taipy Studio to build pipelines and manage different scenarios. The demo covers copying necessary functions into a script file, configuring datanodes, specifying functions for tasks, configuring pipelines, and executing the scenario with Taipy Studio and/or Taipy Core. \n\n\n## Directory Structure\n\n\n- `src/`: Contains the demo source code.\n- `docs/`: contains the images for the documentation\n- `CODE_OF_CONDUCT.md`: Code of conduct for members and contributors of _image-classification-part-2_.\n- `CONTRIBUTING.md`: Instructions to contribute to _image-classification-part-2_.\n- `INSTALLATION.md`: Instructions to install _image-classification-part-2_.\n- `LICENSE`: The Apache 2.0 License.\n- `Pipfile`: File used by the Pipenv virtual environment to manage project dependencies.\n- `README.md`: Current file.\n\n## License\nCopyright 2022 Avaiga Private Limited\n\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with\nthe License. You may obtain a copy of the License at\n[http://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)\n\nUnless required by applicable law or agreed to in writing, software distributed under the License is distributed on\nan \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\nspecific language governing permissions and limitations under the License.\n\n## Installation\n\nWant to install _image-classification-part-2_? Check out our [`INSTALLATION.md`](INSTALLATION.md) file.\n\n## Contributing\n\nWant to help build _image-classification-part-2_? Check out our [`CONTRIBUTING.md`](CONTRIBUTING.md) file.\n\n## Code of conduct\n\nWant to be part of the _image-classification-part-2_ community? Check out our [`CODE_OF_CONDUCT.md`](CODE_OF_CONDUCT.md) file."}
+{"text": "# Create app for demo-image-classification-part-2 config_from_tp_studio.py\nfrom main_functions import *\nfrom taipy import Config\nimport taipy as tp \n\nConfig.load('built_with_tp_studio.toml')\nscenario_cfg = Config.scenarios['testing_scenario']\n\ntp.Core().run()\nmain_scenario = tp.create_scenario(scenario_cfg)\ntp.submit(main_scenario)\n\n\n\n\n\n\n\n"}
+{"text": "# Create app for demo-image-classification-part-2 main_functions.py\nimport tensorflow as tf\nfrom tensorflow.keras import layers, models \nfrom tensorflow.keras.preprocessing.image import ImageDataGenerator \nfrom tensorflow.keras.utils import to_categorical \nimport pandas as pd \nimport numpy as np\n\nclass_names = ['AIRPLANE', 'AUTOMOBILE', 'BIRD', 'CAT', 'DEER', 'DOG', 'FROG', 'HORSE', 'SHIP', 'TRUCK']\n\n(x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data()\n\nx_train = x_train / 255.0\ny_train = to_categorical(y_train, len(class_names))\nx_test = x_test / 255.0\ny_test = to_categorical(y_test, len(class_names))\n\ndef tf_read(path: str): return tf.keras.models.load_model(path)\ndef tf_write(model, path: str):model.save(path)\n\n#Task 1.1: Building the base model\ndef initialize_model(loss_f):\n # Creating model base\n model = models.Sequential()\n model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)))\n model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same'))\n model.add(layers.MaxPool2D((2,2)))\n\n model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same',))\n model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same',))\n model.add(layers.MaxPool2D((2,2)))\n\n model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same',))\n model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same',))\n model.add(layers.MaxPool2D((2,2)))\n\n model.add(layers.Flatten())\n model.add(layers.Dense(128, activation='relu'))\n model.add(layers.Dense(10, activation='softmax'))\n\n model.compile(optimizer='adam',\n loss=loss_f,\n metrics=['accuracy'])\n\n return model\n\n#Task 1.2: Initial training witha fixed number of epochs\ndatagen = ImageDataGenerator(\n horizontal_flip=True,\n width_shift_range=3/32,\n height_shift_range=3/32\n)\n\ndef initial_model_training(n_epochs, model):\n print(\"INITIAL MODEL TRAINING STARTED: \")\n\n h = model.fit(\n datagen.flow(x_train, y_train, batch_size=64),\n epochs=n_epochs,\n validation_data=(x_test, y_test))\n\n training_result = pd.DataFrame.from_dict(h.history)\n training_result[\"N_Epochs\"] = range(1,len(training_result)+1)\n \n return training_result, model\n\n#Task 2.1: Merge train with a chosen number of epochs (training + validation set as training)\ndef merged_train(number_of_epochs,model):\n print(\"MERGED TRAIN STARTED: \")\n # merge the training and validation sets\n x_all = np.concatenate((x_train, x_test))\n y_all = np.concatenate((y_train, y_test))\n\n h = model.fit(\n datagen.flow(x_all, y_all, batch_size=64),\n epochs=number_of_epochs)\n \n training_result = pd.DataFrame.from_dict(h.history)\n training_result[\"N_Epochs\"] = range(1,len(training_result)+1)\n \n return training_result, model\n\n#Task 2.2: Predict image class\ndef predict_image(image_path, trained_model):\n print(\"PREDICTION TASK STARTED: \")\n img_array = tf.keras.utils.load_img(image_path, target_size=(32, 32))\n image = tf.keras.utils.img_to_array(img_array) \n image = np.expand_dims(image, axis=0) / 255. \n prediction_result = class_names[np.argmax(trained_model.predict(image))]\n print(\"Prediction result: {}\".format(prediction_result))\n return prediction_result\n\n"}
+{"text": "# Create app for demo-image-classification-part-2 main.py\nfrom main_functions import *\nfrom taipy import Config\nimport taipy as tp \n\n#######################################################################################################\n##############################################PIPELINE 1###############################################\n#######################################################################################################\n\n###TASK 1.1: Building the base model\n#input dn\nloss_fn_cfg = Config.configure_data_node(\"loss_fn\", default_data='categorical_crossentropy')\n#output dn\nbase_model_cfg = Config.configure_generic_data_node(\"base_model\", \n read_fct=tf_read, read_fct_params=('models/base_model',),\n write_fct=tf_write, write_fct_params=('models/base_model',))\n#task\nBUILD_CNN_BASE_cfg = Config.configure_task(\"BUILD_CNN_BASE\",\n initialize_model,\n loss_fn_cfg,\n base_model_cfg)\n\n###TASK 1.2: Initial training with a fixed number of epochs\n#input dn\ninitial_n_epochs_cfg = Config.configure_data_node(\"initial_n_epochs\", default_data=30)\n#output dn\ninitial_train_perf_cfg = Config.configure_data_node(\"initial_train_perf\")\ntrained_initial_model_cfg = Config.configure_generic_data_node(\"trained_initial_model\", \n read_fct=tf_read, read_fct_params=('models/trained_initial_model',),\n write_fct=tf_write, write_fct_params=('models/trained_initial_model',))\n#task\nINITIAL_TRAIN_cfg = Config.configure_task(\"INITIAL_TRAIN\",\n initial_model_training,\n [initial_n_epochs_cfg, base_model_cfg],\n [initial_train_perf_cfg, trained_initial_model_cfg])\n#pipeline\npipeline_1_cfg = Config.configure_pipeline(\"pipeline_1\",\n [BUILD_CNN_BASE_cfg,\n INITIAL_TRAIN_cfg])\n\n#######################################################################################################\n##############################################PIPELINE 2###############################################\n#######################################################################################################\n\n###TASK 2.1: Merge train with a chosen number of epochs (training + validation set as training)\n#input dn\noptimal_n_epochs_cfg = Config.configure_data_node(\"optimal_n_epochs\", default_data=13)\n#output dn\nmerged_train_perf_cfg = Config.configure_data_node(\"merged_train_perf\")\nmerged_trained_model_cfg = Config.configure_generic_data_node(\"merged_trained_model\", \n read_fct=tf_read, read_fct_params=('models/merged_trained_model',),\n write_fct=tf_write, write_fct_params=('models/merged_trained_model',))\n#task\nMERGED_TRAIN_cfg = Config.configure_task(\"MERGED_TRAIN\",\n merged_train,\n [optimal_n_epochs_cfg, base_model_cfg],\n [merged_train_perf_cfg, merged_trained_model_cfg])\n\n\n###TASK 2.2: Make a prediction from an image path\n#input dn: the trained model datanode, already set up\nimage_path_dn_cfg = Config.configure_data_node(\"image_path_dn\", default_data=\"test_images/dog.jpg\") \n#output dn\nprediction_cfg = Config.configure_data_node(\"image_prediction\")\n#task\nIMAGE_PREDICT_cfg = Config.configure_task(\"IMAGE_PREDICT\", predict_image,\n [image_path_dn_cfg, merged_trained_model_cfg],\n [prediction_cfg])\n#pipeline\npipeline_2_cfg = Config.configure_pipeline(\"pipeline_2\",\n [MERGED_TRAIN_cfg, \n IMAGE_PREDICT_cfg])\n\n\n#######################################################################################################\n##############################################Scenario#################################################\n#######################################################################################################\nscenario_cfg = Config.configure_scenario(\"testing_scenario\",\n [pipeline_1_cfg, pipeline_2_cfg])\n\ntp.Core().run()\nmain_scenario = tp.create_scenario(scenario_cfg)\ntp.submit(main_scenario)\nConfig.export(\"tpcore.toml\")\n\n\n\n\n\n"}
+{"text": "# Create app for demo-edit-log LICENSE.md\n\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright 2022 Avaiga Private Limited\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n"}
+{"text": "# Create app for demo-edit-log main.py\nfrom taipy.gui import Gui\nimport taipy as tp\nfrom taipy.gui import notify\nfrom config.config import *\n\n\n# Variables for bindings\nall_scenarios = [] # List of scenarios\nall_scenarios_configs = [] # List of scenario configs\nall_data_nodes = [] # List of node IDs\n\ncurrent_scenario = None\ncurrent_data_node = None\ncurrent_scenario_config = None\n\nscenario_name = None\nedits = [[\"\",\"\",\"\"]]\n\nvalue = None\ncommit_message = \"\"\ncreate_scenario_dialog_visible = False\nset_value_dialog_visible = False\n\n\n# ====================================================================\n\n\ndef on_init(state):\n state.all_scenarios = [(sc.id, sc.name) for sc in tp.get_scenarios()]\n state.all_scenarios_configs = [sc.id for sc in Config.scenarios.values()]\n\n\ndef on_change_current_scenario(state):\n scenario = tp.get(state.current_scenario[0])\n # Propagate to list of nodes:\n state.all_data_nodes = [(dn.id, dn.config_id) for dn in scenario.data_nodes.values()]\n\ndef on_change(state, var_name: str, var_value):\n if var_name == \"all_data_nodes\":\n # Propagate to current data node (pick any...):\n if var_value and len(var_value) > 0:\n data_node = next(iter(var_value))\n state.current_data_node = data_node\n if var_name == \"current_data_node\":\n # Propagate to list of edits:\n refresh_edit_log(state)\n\n\ndef refresh_edit_log(state):\n # Forces a refresh of the edit log:\n if state.current_data_node:\n data_node_id = state.current_data_node[0]\n data_node = tp.get(data_node_id)\n state.edits = get_edit_log(data_node) if data_node else []\n\n\ndef create_scenario_clicked(state):\n state.scenario_name = None\n state.create_scenario_dialog_visible = True\n\n\ndef get_edit_log(data_node):\n def _get_edit_fields(edit):\n return [str(edit.get(\"timestamp\")), edit.get(\"job_id\"), edit.get(\"message\")]\n\n return [_get_edit_fields(edit) for edit in data_node.edits] if data_node else []\n\n\ndef on_submit_button_clicked(state):\n scenario_id = state.current_scenario[0]\n scenario = tp.get(scenario_id)\n tp.submit(scenario)\n # Force refresh of current data node:\n refresh_edit_log(state)\n notify(state, message=f\"Scenario {scenario.name} submitted!\")\n\n\ndef on_set_value_clicked(state):\n state.set_value_dialog_visible = True\n\n\ndef create_scenario_dialog_action(state, id, action, payload):\n state.create_scenario_dialog_visible = False\n btn_idx = payload[\"args\"][0]\n if btn_idx == 0: # OK button\n scenario_cfg = Config.scenarios[state.current_scenario_config]\n name = state.scenario_name\n scenario = tp.create_scenario(config=scenario_cfg, name=name)\n all_scenarios = state.all_scenarios\n all_scenarios.append((scenario.id, scenario.name))\n state.all_scenarios = all_scenarios\n notify(state, message=f\"Scenario {scenario.name} created!\")\n\n\ndef set_value_dialog_action(state, id, action, payload):\n btn_idx = payload[\"args\"][0]\n if btn_idx == 0: # OK button\n data_node_id = state.current_data_node[0]\n node = tp.get(data_node_id)\n node.write(state.value, message=state.commit_message)\n state.current_data_node = state.current_data_node\n\n state.set_value_dialog_visible = False\n\n\nhistory_table_columns = {\n \"0\": {\"title\": \"Date\"},\n \"1\": {\"title\": \"Job Id\"},\n \"2\": {\"title\": \"Comments\"},\n}\n\n\nscenario_manager_page = \"\"\"\n<|part|class_name=card|\n## Data Node Selection\n<|{current_scenario}|selector|lov={all_scenarios}|dropdown|label=