{"text": "# Display df_selection in an expandable\n<|Sales Table|expandable|expanded=False|"}
{"text": "# Create a Generate text button\n<|Generate text|button|on_action=generate_text|label=Generate text|>"}
{"text": "# Create a text input for the tweet\n<|{tweet}|input|multiline|label=Resulting tweet|class_name=fullwidth|>"}
{"text": "# Break line\n<br/>"}
{"text": "# Display image\n<center><|{image}|image|height=400px|></center>"}
{"text": "# Display image from path\n<|{path}|image|width=500px|height=500px|class_name=img|>"}
{"text": "# Create a slider to select iterations\n<|{iterations}|slider|min=10|max=50|continuous=False|on_change=generate|>"}
{"text": "# Slider dx_start\n<|{dx_start}|slider|min=0|max=100|continuous=False|on_change=generate|>"}
{"text": "# Create a toggle button\n<|{value}|toggle|lov=Item 1;Item 2;Item 3|>"}
{"text": "# Create a dropdown to select between A B and C\n<|{value}|selector|lov=A;B;C|dropdown|>"}
{"text": "# Create a date selector\n<|{dt}|date|>"}
{"text": "# Date selection\n<|{dt}|date|>"}
{"text": "# Create a gauge to visualize progress\n<|message|indicator|value={progress}|min=0|max=100|>"}
{"text": "# Create and register a page:\nfrom taipy import Gui\nGui(\"# This is my page title\")"}
{"text": "# Create a page variable and register it:\nmd = \"# This is my page title\"\nGui(md)"}
{"text": "# Create 2 pages and register them:\npages = {\n  'page1': Markdown(\"# My first page\"),\n  'page2': Markdown(\"# My second page\")\n}\nGui(pages=pages)"}
{"text": "# Create a multi-page application:\nfrom taipy import Gui\n\n   root_md=\"# Multi-page application\"\n   page1_md=\"# This is page 1\"\n   page2_md=\"# This is page 2\"\n\n   pages = {\n     \"/\": root_md,\n     \"page1\": page1_md,\n     \"page2\": page2_md\n   }\n   Gui(pages=pages).run()"}
{"text": "# Create a multi-page application with content placeholder:\n   from taipy import Gui\n\n   root_md=\"\"\"#\n   Multi-page application\n\n\n   This application was created with [Taipy](http://taipy.avaiga.com).\n   \"\"\"\n   page1_md=\"# This is page 1\"\n   page2_md=\"# This is page 2\"\n\n   pages = {\n     \"/\": root_md,\n     \"page1\": page1_md,\n     \"page2\": page2_md\n   }\n   Gui(pages=pages).run()"}
{"text": "# Create a dialog in Markdown content:\n   page=\"\"\"\n   <|{dialog_is_visible}|dialog|\n   Enter a name:\n   <|{name}|input|>\n   |>\"\"\"\n   Gui(page).run()"}
{"text": "# Create a partial page:\n    gui = Gui()\n    prompt_user = gui.add_partial(\n     \"\"\"\n     Enter a name:\n     <|{name}|input|>\n     \"\"\"\n   )\n   gui.run()"}
{"text": "# Display a value:\n<|{value}|>"}
{"text": "# Format the value with 2 decimal places:\n<|{value}|text|format=%.2f|>"}
{"text": "# Create a button with Button Label:\n<|Button Label|button|>"}
{"text": "# Create a Save button:\n<|Button Label|button|>"}
{"text": "# Create a Cancel button and button_action_function_name:\n<|Cancel|button|on_action=button_action_function_name|>"}
{"text": "# Create a Cancel button with cancel function:\n<|Cancel|button|on_action=cancel|>"}
{"text": "# Create input field for name:\n<|{name}|input|>"}
{"text": "# Create input field for address:\n<|{address}|input|>"}
{"text": "# Create number field for age:\n<|{age}|number|>"}
{"text": "# Create a slider for value between 1 and 10:\n<|{value}|slider|min=1|max=10|>"}
{"text": "# Create a list of toggle buttons for Item 1, Item 2, Item 3:\n<|{value}|toggle|lov=Item 1;Item 2;Item 3|>"}
{"text": "# Create a toggle control that lets you pick a specific user:\n<|{user_sel}|toggle|lov={users}|type=User|adapter={lambda u: (u.id, u.name)}|>"}
{"text": "# Create a date selector:\n<|{dt}|date|>"}
{"text": "# Create a date selector without time:\n<|{dt}|date|not with_time|>"}
{"text": "# Create a date selector with only date:\n<|{dt}|date|not with_time|>"}
{"text": "# Create a file download:\n<|{content}|file_download|>"}
{"text": "# Create a file download with action:\n<|{content}|file_download|label=Download File|on_action=function_name|name=filename|>"}
{"text": "# Create a file download with no review:\n<|{content}|file_download|bypass_preview=False|>"}
{"text": "# Create an auto download file download:\n<|{content}|file_download|auto|>"}
{"text": "# Create a file selector:\n<|{content}|file_selector|>"}
{"text": "# Create a file selector with label and action:\n<|{content}|file_selector|label=Download File|on_action=function_name|extensions=.csv,.xlsx|drop_message=Drop Message|>"}
{"text": "# Create a multiple file uploader:\n<|{content}|file_selector|multiple|>"}
{"text": "# Show an image:\n<|{content}|image|>"}
{"text": "# Show an image with label and callback:\n<|{content}|image|label=this is an image|on_action=function_name|>"}
{"text": "# Defining a simple static menu:\n<|menu|lov=menu 1;menu 2|>"}
{"text": "# Show a table:\n<|{data}|table|>"}
{"text": "# Display a list of string:\n<|{value}|tree|lov=Item 1;Item 2;Item 3|>"}
{"text": "# Display df_display in an expandable\n<|Display Table|expandable|expanded=False|"}
{"text": "# Create a text input for the note\n<|{note}|input|multiline|label=Note|class_name=fullwidth|>"}
{"text": "# Insert a line break\n<br/>"}
{"text": "# Display plot\n<center><|{plot}|image|height=400px|></center>"}
{"text": "# Display plot from file location\n<|{file_location}|image|width=500px|height=500px|class_name=img|>"}
{"text": "# Create a slider to adjust volume\n<|{volume}|slider|min=0|max=100|continuous=False|on_change=adjust_volume|>"}
{"text": "# Slider dx_threshold\n<|{dx_threshold}|slider|min=0|max=10|continuous=False|on_change=update_threshold|>"}
{"text": "# Create a toggle button\n<|{is_enabled}|toggle|lov=Off;On|>"}
{"text": "# Create a dropdown to select between Option X, Option Y, and Option Z\n<|{option}|selector|lov=Option X;Option Y;Option Z|dropdown|>"}
{"text": "# Create a date picker\n<|{selected_date}|date|>"}
{"text": "# Date picker\n<|{selected_date}|date|>"}
{"text": "# Create a Cancel button with cancel_handler function:\n<|Cancel|button|on_action=cancel_handler|>"}
{"text": "# Create an input field for username:\n<|{username}|input|>"}
{"text": "# Create an input field for location:\n<|{location}|input|>"}
{"text": "# Create a numeric field for age:\n<|{age}|number|>"}
{"text": "# Create a slider for value between 1 and 10:\n<|{rating}|slider|min=1|max=10|>"}
{"text": "# Create a set of toggle buttons for Option 1, Option 2, Option 3:\n<|{choice}|toggle|lov=Option 1;Option 2;Option 3|>"}
{"text": "# Create a toggle control to select a specific category:\n<|{category_sel}|toggle|lov={categories}|type=Category|adapter={lambda c: (c.id, c.name)}|>"}
{"text": "# Create a date picker:\n<|{event_date}|date|>"}
{"text": "# Create a date picker without time:\n<|{event_date}|date|not with_time|>"}
{"text": "# Create a date picker with only date:\n<|{event_date}|date|not with_time|>"}
{"text": "# Create a file download link:\n<|{document}|file_download|>"}
{"text": "# Create a file download link with action:\n<|{document}|file_download|label=Download Document|on_action=download_file|name=file_name|>"}
{"text": "# Create a file download link without preview:\n<|{document}|file_download|bypass_preview=False|>"}
{"text": "# Create an auto download file link:\n<|{document}|file_download|auto|>"}
{"text": "# Create a file selector:\n<|{selected_file}|file_selector|>"}
{"text": "# Create a file selector with label and action:\n<|{selected_file}|file_selector|label=Select File|on_action=file_selected|extensions=.csv,.xlsx|drop_message=Drop file here|>"}
{"text": "# Create a multiple file uploader:\n<|{selected_files}|file_selector|multiple|>"}
{"text": "# Show an illustration:\n<|{illustration}|image|>"}
{"text": "# Show an image with description and callback:\n<|{picture}|image|label=This is a picture|on_action=image_clicked|>"}
{"text": "# Display a message at a specified position between min and max:\n<|status|indicator|value={percentage}|min=0|max=100|>"}
{"text": "# Define a basic static menu:\n<|menu|lov=menu_item1;menu_item2|>"}
{"text": "# Display df_results in an expandable\n<|Results Table|expandable|expanded=False|"}
{"text": "# Create a Generate summary button\n<|Generate summary|button|on_action=generate_summary|label=Generate summary|>"}
{"text": "# Create a text input for the article\n<|{article}|input|multiline|label=Resulting article|class_name=fullwidth|>"}
{"text": "# Insert a line break\n<br/>"}
{"text": "# Display chart\n<center><|{chart}|image|height=400px|></center>"}
{"text": "# Display chart from file path\n<|{file_path}|image|width=500px|height=500px|class_name=img|>"}
{"text": "# Create a slider to adjust zoom level\n<|{zoom_level}|slider|min=1|max=5|continuous=False|on_change=adjust_zoom|>"}
{"text": "# Slider dx_threshold\n<|{dx_threshold}|slider|min=0|max=10|continuous=False|on_change=update_threshold|>"}
{"text": "# Create a toggle switch\n<|{state}|toggle|lov=Off;On;Auto|>"}
{"text": "# Create a dropdown to select between X, Y, and Z\n<|{axis}|selector|lov=X;Y;Z|dropdown|>"}
{"text": "# Date picker\n<|{selected_date}|date|>"}
{"text": "# Create a gauge to visualize value\n<|status|indicator|value={progress}|min=0|max=100|>"}
{"text": "# Define a page variable and initialize it:\nmd_content = \"# My Page Title\"\nGui(md_content)"}
{"text": "# Define 2 pages and set them up:\ncontent_pages = {\n 'first_page': Markdown(\"# Introduction\"),\n 'second_page': Markdown(\"# Advanced Topics\")\n}\nGui(pages=content_pages)"}
{"text": "# Set up a multi-page application:\nfrom taipy import Gui\n\n root_content=\"# Welcome to the App\"\n page1_content=\"# This is Page 1\"\n page2_content=\"# This is Page 2\"\n\n pages_dict = {\n \"/\": root_content,\n \"page1\": page1_content,\n \"page2\": page2_content\n }\n Gui(pages=pages_dict).run()"}
{"text": "# Set up a multi-page application with content placeholder:\n from taipy import Gui\n\n root_content=\"\"\"#\n Multi-page application\n\n\n This app was built using Taipy.\n \"\"\"\n page1_content=\"# Page 1\"\n page2_content=\"# Page 2\"\n\n pages_dict = {\n \"/\": root_content,\n \"page1\": page1_content,\n \"page2\": page2_content\n }\n Gui(pages=pages_dict).run()"}
{"text": "# Create a dialog with Markdown content:\n dialog_content=\"\"\"\n <|{is_visible}|dialog|\n Please enter your name:\n <|{user_name}|input|>\n |>\"\"\"\n Gui(dialog_content).run()"}
{"text": "# Set up a partial page:\n gui_instance = Gui()\n user_prompt = gui_instance.add_partial(\n \"\"\"\n Please enter your name:\n <|{user_name}|input|>\n \"\"\"\n )\n gui_instance.run()"}
{"text": "# Display a calculated result:\n<|{result}|>"}
{"text": "# Format the value with 2 decimal points:\n<|{value}|text|format=%.2f|>"}
{"text": "# Create a button with the label 'Click Me':\n<|Click Me|button|>"}
{"text": "# Create a Save button:\n<|Save|button|>"}
{"text": "# Create a Cancel button with cancel_handler function:\n<|Cancel|button|on_action=cancel_handler|>"}
{"text": "# Create an input field for username:\n<|{username}|input|>"}
{"text": "# Create an input field for location:\n<|{location}|input|>"}
{"text": "# Create a numeric field for age:\n<|{age}|number|>"}
{"text": "# Create a slider for value between 1 and 10:\n<|{rating}|slider|min=1|max=10|>"}
{"text": "# Create a set of toggle buttons for Option 1, Option 2, Option 3:\n<|{choice}|toggle|lov=Option 1;Option 2;Option 3|>"}
{"text": "# Create a toggle control to select a specific category:\n<|{category_sel}|toggle|lov={categories}|type=Category|adapter={lambda c: (c.id, c.name)}|>"}
{"text": "# Create a date picker:\n<|{event_date}|date|>"}
{"text": "# Create a date picker without time:\n<|{event_date}|date|not with_time|>"}
{"text": "# Create a date picker with only date:\n<|{event_date}|date|not with_time|>"}
{"text": "# Create a file download link:\n<|{document}|file_download|>"}
{"text": "# Create a file download link with action:\n<|{document}|file_download|label=Download Document|on_action=download_file|name=file_name|>"}
{"text": "# Create a file download link without preview:\n<|{document}|file_download|bypass_preview=False|>"}
{"text": "# Create an auto download file link:\n<|{document}|file_download|auto|>"}
{"text": "# Create a file selector:\n<|{selected_file}|file_selector|>"}
{"text": "# Create a file selector with label and action:\n<|{selected_file}|file_selector|label=Select File|on_action=file_selected|extensions=.csv,.xlsx|drop_message=Drop file here|>"}
{"text": "# Show an illustration:\n<|{illustration}|image|>"}
{"text": "# Show an image with description and callback:\n<|{picture}|image|label=This is a picture|on_action=image_clicked|>"}
{"text": "# Display a message at a specified position between min and max:\n<|status|indicator|value={percentage}|min=0|max=100|>"}
{"text": "# Define a basic static menu:\n<|menu|lov=menu_item1;menu_item2|>"}
{"text": "# Display df_output in an expandable\n<|Output Table|expandable|expanded=False|"}
{"text": "# Create a Visualize button\n<|Visualize|button|on_action=visualize_data|label=Visualize|>"}
{"text": "# Create a text input for the description\n<|{description}|input|multiline|label=Description|class_name=fullwidth|>"}
{"text": "# Insert a line break\n<br/>"}
{"text": "# Display diagram\n<center><|{diagram}|image|height=400px|></center>"}
{"text": "# Display diagram from file path\n<|{diagram_path}|image|width=500px|height=500px|class_name=img|>"}
{"text": "# Create a slider to adjust brightness\n<|{brightness}|slider|min=0|max=100|continuous=False|on_change=adjust_brightness|>"}
{"text": "# Slider threshold\n<|{threshold}|slider|min=0|max=10|continuous=False|on_change=update_threshold|>"}
{"text": "# Create a toggle button\n<|{is_enabled}|toggle|lov=Off;On|>"}
{"text": "# Create a dropdown to select between Choice A, Choice B, and Choice C\n<|{choice}|selector|lov=Choice A;Choice B;Choice C|dropdown|>"}
{"text": "# Create a date picker\n<|{selected_date}|date|>"}
{"text": "# Date picker\n<|{selected_date}|date|>"}
{"text": "# Create a gauge to visualize value\n<|status|indicator|value={progress}|min=0|max=100|>"}
{"text": "# Create and initialize a page:\nfrom taipy import Gui\nGui(\"# Dashboard\")"}
{"text": "# Define a page variable and initialize it:\nmd_content = \"# Dashboard\"\nGui(md_content)"}
{"text": "# Define 2 pages and set them up:\ncontent_pages = {\n 'overview': Markdown(\"# Overview\"),\n 'details': Markdown(\"# Details\")\n}\nGui(pages=content_pages)"}
{"text": "# Set up a multi-page application:\nfrom taipy import Gui\n\n root_content=\"# Welcome to the App\"\n page1_content=\"# Page 1\"\n page2_content=\"# Page 2\"\n\n pages_dict = {\n \"/\": root_content,\n \"page1\": page1_content,\n \"page2\": page2_content\n }\n Gui(pages=pages_dict).run()"}
{"text": "# Set up a multi-page application with content placeholder:\n from taipy import Gui\n\n root_content=\"\"\"#\n Multi-page application\n\n\n This app was built using Taipy.\n \"\"\"\n page1_content=\"# Page 1\"\n page2_content=\"# Page 2\"\n\n pages_dict = {\n \"/\": root_content,\n \"page1\": page1_content,\n \"page2\": page2_content\n }\n Gui(pages=pages_dict).run()"}
{"text": "# Create a dialog with Markdown content:\n dialog_content=\"\"\"\n <|{is_visible}|dialog|\n Please enter your name:\n <|{user_name}|input|>\n |>\"\"\"\n Gui(dialog_content).run()"}
{"text": "# Set up a partial page:\n gui_instance = Gui()\n user_prompt = gui_instance.add_partial(\n \"\"\"\n Please enter your name:\n <|{user_name}|input|>\n \"\"\"\n )\n gui_instance.run()"}
{"text": "# Display a calculated result:\n<|{result}|>"}
{"text": "# Format the value with 2 decimal points:\n<|{value}|text|format=%.2f|>"}
{"text": "# Create a button with the label 'Click Me':\n<|Click Me|button|>"}
{"text": "# Create a Save button:\n<|Save|button|>"}
{"text": "# Create a Cancel button and set the action function name:\n<|Cancel|button|on_action=cancel_action_function|>"}
{"text": "# Create a Cancel button with cancel_handler function:\n<|Cancel|button|on_action=cancel_handler|>"}
{"text": "# Create an input field for username:\n<|{username}|input|>"}
{"text": "# Create an input field for location:\n<|{location}|input|>"}
{"text": "# Create a numeric field for age:\n<|{age}|number|>"}
{"text": "# Create a slider for value between 1 and 10:\n<|{rating}|slider|min=1|max=10|>"}
{"text": "# Create a set of toggle buttons for Option 1, Option 2, Option 3:\n<|{choice}|toggle|lov=Option 1;Option 2;Option 3|>"}
{"text": "# Create a toggle control to select a specific category:\n<|{category_sel}|toggle|lov={categories}|type=Category|adapter={lambda c: (c.id, c.name)}|>"}
{"text": "# Create a date picker:\n<|{event_date}|date|>"}
{"text": "# Create a date picker without time:\n<|{event_date}|date|not with_time|>"}
{"text": "# Create a date picker with only date:\n<|{event_date}|date|not with_time|>"}
{"text": "# Create a file download link:\n<|{document}|file_download|>"}
{"text": "# Create a file download link with action:\n<|{document}|file_download|label=Download Document|on_action=download_file|name=file_name|>"}
{"text": "# Create a file download link without preview:\n<|{document}|file_download|bypass_preview=False|>"}
{"text": "# Create an auto download file link:\n<|{document}|file_download|auto|>"}
{"text": "# Create a file selector:\n<|{selected_file}|file_selector|>"}
{"text": "# Create a file selector with label and action:\n<|{selected_file}|file_selector|label=Select File|on_action=file_selected|extensions=.csv,.xlsx|drop_message=Drop file here|>"}
{"text": "# Create a multiple file uploader:\n<|{selected_files}|file_selector|multiple|>"}
{"text": "# Show an illustration:\n<|{illustration}|image|>"}
{"text": "# Show an image with description and callback:\n<|{picture}|image|label=This is a picture|on_action=image_clicked|>"}
{"text": "# Display a message at a specified position between min and max:\n<|status|indicator|value={percentage}|min=0|max=100|>"}
{"text": "# Define a basic static menu:\n<|menu|lov=menu_item1;menu_item2|>"}
{"text": "# Display df_display in an expandable\n<|Display Data|expandable|expanded=False|"}
{"text": "# Create an Explore button\n<|Explore|button|on_action=explore_data|label=Explore|>"}
{"text": "# Create a text input for the notes\n<|{notes}|input|multiline|label=Notes|class_name=fullwidth|>"}
{"text": "# Insert a line break\n<br/>"}
{"text": "# Display visualization\n<center><|{visualization}|image|height=400px|></center>"}
{"text": "# Display visualization from file path\n<|{file_path}|image|width=500px|height=500px|class_name=img|>"}
{"text": "# Create a slider to adjust contrast\n<|{contrast}|slider|min=0|max=100|continuous=False|on_change=adjust_contrast|>"}
{"text": "# Slider threshold\n<|{threshold}|slider|min=0|max=10|continuous=False|on_change=update_threshold|>"}
{"text": "# Create and initialize a page:\nfrom taipy import Gui\nGui(\"# Data Overview\")"}
{"text": "# Define a page variable and initialize it:\nmd_content = \"# Data Overview\"\nGui(md_content)"}
{"text": "# Define 2 pages and set them up:\ncontent_pages = {\n 'overview': Markdown(\"# Overview\"),\n 'details': Markdown(\"# Details\")\n}\nGui(pages=content_pages)"}
{"text": "# Set up a multi-page application:\nfrom taipy import Gui\n\n root_content=\"# Welcome to the App\"\n page1_content=\"# Page 1\"\n page2_content=\"# Page 2\"\n\n pages_dict = {\n \"/\": root_content,\n \"page1\": page1_content,\n \"page2\": page2_content\n }\n Gui(pages=pages_dict).run()"}
{"text": "# Set up a multi-page application with content placeholder:\n from taipy import Gui\n\n root_content=\"\"\"#\n Multi-page application\n\n\n This app was built using Taipy.\n \"\"\"\n page1_content=\"# Page 1\"\n page2_content=\"# Page 2\"\n\n pages_dict = {\n \"/\": root_content,\n \"page1\": page1_content,\n \"page2\": page2_content\n }\n Gui(pages=pages_dict).run()"}
{"text": "# Create a dialog with Markdown content:\n dialog_content=\"\"\"\n <|{is_visible}|dialog|\n Please enter your name:\n <|{user_name}|input|>\n |>\"\"\"\n Gui(dialog_content).run()"}
{"text": "# Set up a partial page:\n gui_instance = Gui()\n user_prompt = gui_instance.add_partial(\n \"\"\"\n Please enter your name:\n <|{user_name}|input|>\n \"\"\"\n )\n gui_instance.run()"}
{"text": "# Display a calculated result:\n<|{result}|>"}
{"text": "# Format the value with 2 decimal points:\n<|{value}|text|format=%.2f|>"}
{"text": "# Create a button with the label 'Click Me':\n<|Click Me|button|>"}
{"text": "# Create a Save button:\n<|Save|button|>"}
{"text": "# Create a Cancel button and set the action function name:\n<|Cancel|button|on_action=cancel_action_function|>"}
{"text": "# Create a Cancel button with cancel_handler function:\n<|Cancel|button|on_action=cancel_handler|>"}
{"text": "# Create an input field for username:\n<|{username}|input|>"}
{"text": "# Create an input field for location:\n<|{location}|input|>"}
{"text": "# Create a numeric field for age:\n<|{age}|number|>"}
{"text": "# Create a slider for value between 1 and 10:\n<|{rating}|slider|min=1|max=10|>"}
{"text": "# Create a set of toggle buttons for Option 1, Option 2, Option 3:\n<|{choice}|toggle|lov=Option 1;Option 2;Option 3|>"}
{"text": "# Create a toggle control to select a specific category:\n<|{category_sel}|toggle|lov={categories}|type=Category|adapter={lambda c: (c.id, c.name)}|>"}
{"text": "# Create a date picker:\n<|{event_date}|date|>"}
{"text": "# Create a date picker without time:\n<|{event_date}|date|not with_time|>"}
{"text": "# Create a date picker with only date:\n<|{event_date}|date|not with_time|>"}
{"text": "# Create a file download link:\n<|{document}|file_download|>"}
{"text": "# Create a file download link with action:\n<|{document}|file_download|label=Download Document|on_action=download_file|name=file_name|>"}
{"text": "# Create a file download link without preview:\n<|{document}|file_download|bypass_preview=False|>"}
{"text": "# Create an auto download file link:\n<|{document}|file_download|auto|>"}
{"text": "# Create a file selector:\n<|{selected_file}|file_selector|>"}
{"text": "# Create a file selector with label and action:\n<|{selected_file}|file_selector|label=Select File|on_action=file_selected|extensions=.csv,.xlsx|drop_message=Drop file here|>"}
{"text": "# Create a multiple file uploader:\n<|{selected_files}|file_selector|multiple|>"}
{"text": "# Show an illustration:\n<|{illustration}|image|>"}
{"text": "# Show an image with description and callback:\n<|{picture}|image|label=This is a picture|on_action=image_clicked|>"}
{"text": "# Display a message at a specified position between min and max:\n<|status|indicator|value={percentage}|min=0|max=100|>"}
{"text": "# Define a basic static menu:\n<|menu|lov=menu_item1;menu_item2|>"}
{"text": "# Plot Sales according to Date in a line chart:\n<|{data}|chart|type=lines|x=DATE|y=SALES|>"}
{"text": "# Plot Sales according to Date in a line chart titled \"Sales according to Revenue\":\n<|{data}|chart|type=lines|x=DATE|x=SALES|title=SALES according to Revenue|>"}
{"text": "# Plot Sales and Revenue according to Date:\n<|{data}|chart|type=lines|x=DATE|y[1]=SALES|y[2]=REVENUE|>"}
{"text": "# Plot Sales according to Date on a Dashed line:\n<|{data}|chart|type=lines|x=DATE|x=SALES|line=dash|>"}
{"text": "# Plot Revenue by Date on a dotted line:\n<|{data}|chart|type=lines|x=DATE|x=SALES|line=dot|>"}
{"text": "# Plot Sales by Date in Red:\n<|{data}|chart|type=lines|x=DATE|x=SALES|color=Red|>"}
{"text": "# Plot Revenue according to Date in yellow:\n<|{data}|chart|type=lines|x=DATE|x=SALES|color=Yellow|>"}
{"text": "# Plot Revenue according to Date in yellow titled Revenue Plot:\n<|{data}|chart|type=lines|x=DATE|x=SALES|color=Yellow|title=REVENUE Plot>"}
{"text": "# Plot Sales in blue and Revenue in green according to Date:\n<|{data}|chart|type=lines|x=DATE|y[1]=SALES|y[2]=REVENUE|color[1]=blue|color[2]=green|>"}
{"text": "# Plot Revenue by Date in a red dashed line and Sales in a yellow Dotted line:\n<|{data}|chart|type=lines|x=DATE|y[1]=REVENUE|y[2]=SALES|line[1]=dash|line[2]=dot|color[1]=red|color[2]=yellow|>"}
{"text": "# Display Date according to Sales:\n<|{data}|chart|type=lines|x=DATE|x=SALES|>"}
{"text": "# Plot in a bar chart the Sales according to Date:\n<|{data}|chart|type=bar|x=DATE|x=SALES|>"}
{"text": "# Plot in a bar chart the Sales according to Date and Revenue according to Date:\n<|{data}|chart|type=bar|x=DATE|y[1]=SALES|y[2]=REVENUE|>"}
{"text": "# Plot Sales and Revenue by Date in a bar chart:\n<|{data}|chart|type=bar|x=DATE|y[1]=SALES|y[2]=REVENUE|>"}
{"text": "# Plot in a bar chart the Sales according to Date and Revenue according to Date titled Finance:\n<|{data}|chart|type=bar|x=DATE|y[1]=SALES|y[2]=REVENUE|title=Finance|>"}
{"text": "# Plot in a scatter plot Sales according to Date:\n<|{data}|chart|type=scatter|mode=markers|x=DATE|x=SALES|>"}
{"text": "# Draw Sales and Revenue by Date in a scatter plot:\n<|{data}|chart|type=scatter|mode=markers|x=DATE|y[1]=SALES|y[2]=REVENUE|>"}
{"text": "# Plot Revenue in green points and Sales in yellow points by Date:\n<|{data}|chart|type=scatter|mode=markers|x=DATE|y[1]=REVENUE|y[2]=SALES|color[1]=green|color[2]=yellow|>"}
{"text": "# Plot a histogram of Sales:\n<|{data}|chart|type=histogram|x=SALES|>"}
{"text": "# Display a horizontal histogram of Sales:\n<|{data}|chart|type=histogram|x=SALES|>"}
{"text": "# Plot the distribution of Sales and Revenue:\n<|{data}|chart|type=histogram|x[1]=SALES|x[2]=REVENUE|>"}
{"text": "# Plot the distribution of Sales and Revenue titled \"Sales and Revenue Distribution\":\n<|{data}|chart|type=histogram|x[1]=SALES|x[2]=REVENUE|title=SALES and Revenue Distribution|>"}
{"text": "# Display a horizontal distribution of Sales and Revenue titled \"Sales and Revenue Distribution\":\n<|{data}|chart|type=histogram|y[1]=SALES|y[2]=REVENUE|title=SALES and Revenue Distribution|>"}
{"text": "# Plot a pie chart of Sales by Date:\n<|{data}|chart|type=pie|values=SALES|labels=Date|>"}
{"text": "# Draw a pie chart of Sales by Date titled \"Sales Pie Chart\":\n<|{data}|chart|type=pie|values=SALES|labels=Date|title=SALES Pie Chart|>"}
{"text": "# Plot a pie chart of Revenue by Date:\n<|{data}|chart|type=pie|values=REVENUE|labels=Date|>"}
{"text": "# Visualize Profit over Time in a line chart:\n<|{data}|chart|type=lines|x=TIME|y=PROFIT|>"}
{"text": "# Showcase Profit over Time in a line chart titled \"Profit Trend\":\n<|{data}|chart|type=lines|x=TIME|y=PROFIT|title=Profit Trend|>"}
{"text": "# Depict Profit and Loss over Time:\n<|{data}|chart|type=lines|x=TIME|y[1]=PROFIT|y[2]=LOSS|>"}
{"text": "# Illustrate Profit over Time with a Dashed line:\n<|{data}|chart|type=lines|x=TIME|y=PROFIT|line=dash|>"}
{"text": "# Present Loss by Time on a Dotted line:\n<|{data}|chart|type=lines|x=TIME|y=LOSS|line=dot|>"}
{"text": "# Plot Profit over Time in Red:\n<|{data}|chart|type=lines|x=TIME|y=PROFIT|color=Red|>"}
{"text": "# Exhibit Loss over Time in yellow:\n<|{data}|chart|type=lines|x=TIME|y=LOSS|color=Yellow|>"}
{"text": "# Show Profit over Time in yellow titled Profit Overview:\n<|{data}|chart|type=lines|x=TIME|y=PROFIT|color=Yellow|title=Profit Overview|>"}
{"text": "# Display Profit in blue and Loss in green over Time:\n<|{data}|chart|type=lines|x=TIME|y[1]=PROFIT|y[2]=LOSS|color[1]=blue|color[2]=green|>"}
{"text": "# Visualize Loss by Time in a red dashed line and Profit in a yellow Dotted line:\n<|{data}|chart|type=lines|x=TIME|y[1]=LOSS|y[2]=PROFIT|line[1]=dash|line[2]=dot|color[1]=red|color[2]=yellow|>"}
{"text": "# Highlight Time according to Profit:\n<|{data}|chart|type=lines|x=TIME|y=PROFIT|>"}
{"text": "# Depict in a bar chart the Profit over Time:\n<|{data}|chart|type=bar|x=TIME|y=PROFIT|>"}
{"text": "# Depict in a bar chart the Profit over Time and Loss over Time:\n<|{data}|chart|type=bar|x=TIME|y[1]=PROFIT|y[2]=LOSS|>"}
{"text": "# Showcase Profit and Loss by Time in a bar chart:\n<|{data}|chart|type=bar|x=TIME|y[1]=PROFIT|y[2]=LOSS|>"}
{"text": "# Depict in a bar chart the Profit over Time and Loss over Time titled Financial Overview:\n<|{data}|chart|type=bar|x=TIME|y[1]=PROFIT|y[2]=LOSS|title=Financial Overview|>"}
{"text": "# Depict in a scatter plot Profit over Time:\n<|{data}|chart|type=scatter|mode=markers|x=TIME|y=PROFIT|>"}
{"text": "# Illustrate Profit and Loss by Time in a scatter plot:\n<|{data}|chart|type=scatter|mode=markers|x=TIME|y[1]=PROFIT|y[2]=LOSS|>"}
{"text": "# Plot Loss in green points and Profit in yellow points by Time:\n<|{data}|chart|type=scatter|mode=markers|x=TIME|y[1]=LOSS|y[2]=PROFIT|color[1]=green|color[2]=yellow|>"}
{"text": "# Display a histogram of Profit:\n<|{data}|chart|type=histogram|x=PROFIT|>"}
{"text": "# Showcase a horizontal histogram of Profit:\n<|{data}|chart|type=histogram|x=PROFIT|>"}
{"text": "# Illustrate the distribution of Profit and Loss:\n<|{data}|chart|type=histogram|x[1]=PROFIT|x[2]=LOSS|>"}
{"text": "# Illustrate the distribution of Profit and Loss titled \"Profit and Loss Distribution\":\n<|{data}|chart|type=histogram|x[1]=PROFIT|x[2]=LOSS|title=Profit and Loss Distribution|>"}
{"text": "# Present a horizontal distribution of Profit and Loss titled \"Profit and Loss Distribution\":\n<|{data}|chart|type=histogram|y[1]=PROFIT|y[2]=LOSS|title=Profit and Loss Distribution|>"}
{"text": "# Depict a pie chart of Profit by Time:\n<|{data}|chart|type=pie|values=PROFIT|labels=Time|>"}
{"text": "# Illustrate a pie chart of Profit by Time titled \"Profit Pie Chart\":\n<|{data}|chart|type=pie|values=PROFIT|labels=Time|title=Profit Pie Chart|>"}
{"text": "# Depict a pie chart of Loss by Time:\n<|{data}|chart|type=pie|values=LOSS|labels=Time|>"}
{"text": "# Visualize Quantity over Time in a line chart:\n<|{data}|chart|type=lines|x=TIME|y=QUANTITY|>"}
{"text": "# Showcase Quantity over Time in a line chart titled \"Quantity Trend\":\n<|{data}|chart|type=lines|x=TIME|y=QUANTITY|title=Quantity Trend|>"}
{"text": "# Depict Quantity and Price over Time:\n<|{data}|chart|type=lines|x=TIME|y[1]=QUANTITY|y[2]=PRICE|>"}
{"text": "# Illustrate Quantity over Time with a Dashed line:\n<|{data}|chart|type=lines|x=TIME|y=QUANTITY|line=dash|>"}
{"text": "# Present Price by Time on a Dotted line:\n<|{data}|chart|type=lines|x=TIME|y=PRICE|line=dot|>"}
{"text": "# Plot Quantity over Time in Green:\n<|{data}|chart|type=lines|x=TIME|y=QUANTITY|color=Green|>"}
{"text": "# Exhibit Price over Time in Blue:\n<|{data}|chart|type=lines|x=TIME|y=PRICE|color=Blue|>"}
{"text": "# Show Price over Time in Blue titled Price Overview:\n<|{data}|chart|type=lines|x=TIME|y=PRICE|color=Blue|title=Price Overview|>"}
{"text": "# Display Quantity in Red and Price in Yellow over Time:\n<|{data}|chart|type=lines|x=TIME|y[1]=QUANTITY|y[2]=PRICE|color[1]=Red|color[2]=Yellow|>"}
{"text": "# Visualize Price by Time in a Green dashed line and Quantity in a Yellow Dotted line:\n<|{data}|chart|type=lines|x=TIME|y[1]=PRICE|y[2]=QUANTITY|line[1]=dash|line[2]=dot|color[1]=Green|color[2]=Yellow|>"}
{"text": "# Highlight Time according to Quantity:\n<|{data}|chart|type=lines|x=TIME|y=QUANTITY|>"}
{"text": "# Depict in a bar chart the Quantity over Time:\n<|{data}|chart|type=bar|x=TIME|y=QUANTITY|>"}
{"text": "# Depict in a bar chart the Quantity over Time and Price over Time:\n<|{data}|chart|type=bar|x=TIME|y[1]=QUANTITY|y[2]=PRICE|>"}
{"text": "# Showcase Quantity and Price by Time in a bar chart:\n<|{data}|chart|type=bar|x=TIME|y[1]=QUANTITY|y[2]=PRICE|>"}
{"text": "# Depict in a bar chart the Quantity over Time and Price over Time titled Product Overview:\n<|{data}|chart|type=bar|x=TIME|y[1]=QUANTITY|y[2]=PRICE|title=Product Overview|>"}
{"text": "# Depict in a scatter plot Quantity over Time:\n<|{data}|chart|type=scatter|mode=markers|x=TIME|y=QUANTITY|>"}
{"text": "# Illustrate Quantity and Price by Time in a scatter plot:\n<|{data}|chart|type=scatter|mode=markers|x=TIME|y[1]=QUANTITY|y[2]=PRICE|>"}
{"text": "# Plot Price in Green points and Quantity in Yellow points by Time:\n<|{data}|chart|type=scatter|mode=markers|x=TIME|y[1]=PRICE|y[2]=QUANTITY|color[1]=Green|color[2]=Yellow|>"}
{"text": "# Display a histogram of Quantity:\n<|{data}|chart|type=histogram|x=QUANTITY|>"}
{"text": "# Showcase a horizontal histogram of Quantity:\n<|{data}|chart|type=histogram|x=QUANTITY|>"}
{"text": "# Illustrate the distribution of Quantity and Price:\n<|{data}|chart|type=histogram|x[1]=QUANTITY|x[2]=PRICE|>"}
{"text": "# Illustrate the distribution of Quantity and Price titled \"Quantity and Price Distribution\":\n<|{data}|chart|type=histogram|x[1]=QUANTITY|x[2]=PRICE|title=Quantity and Price Distribution|>"}
{"text": "# Present a horizontal distribution of Quantity and Price titled \"Quantity and Price Distribution\":\n<|{data}|chart|type=histogram|y[1]=QUANTITY|y[2]=PRICE|title=Quantity and Price Distribution|>"}
{"text": "# Depict a pie chart of Quantity by Time:\n<|{data}|chart|type=pie|values=QUANTITY|labels=Time|>"}
{"text": "# Illustrate a pie chart of Quantity by Time titled \"Quantity Pie Chart\":\n<|{data}|chart|type=pie|values=QUANTITY|labels=Time|title=Quantity Pie Chart|>"}
{"text": "# Depict a pie chart of Price by Time:\n<|{data}|chart|type=pie|values=PRICE|labels=Time|>"}
{"text": "# Plot Temperature against Time in a line chart:\n<|{data}|chart|type=lines|x=TIME|y=TEMPERATURE|>"}
{"text": "# Showcase Temperature against Time in a line chart titled \"Temperature Trend\":\n<|{data}|chart|type=lines|x=TIME|y=TEMPERATURE|title=Temperature Trend|>"}
{"text": "# Depict Temperature and Humidity against Time:\n<|{data}|chart|type=lines|x=TIME|y[1]=TEMPERATURE|y[2]=HUMIDITY|>"}
{"text": "# Illustrate Temperature against Time with a Dashed line:\n<|{data}|chart|type=lines|x=TIME|y=TEMPERATURE|line=dash|>"}
{"text": "# Present Humidity by Time on a Dotted line:\n<|{data}|chart|type=lines|x=TIME|y=HUMIDITY|line=dot|>"}
{"text": "# Plot Temperature against Time in Blue:\n<|{data}|chart|type=lines|x=TIME|y=TEMPERATURE|color=Blue|>"}
{"text": "# Exhibit Humidity against Time in Green:\n<|{data}|chart|type=lines|x=TIME|y=HUMIDITY|color=Green|>"}
{"text": "# Show Humidity against Time in Green titled Humidity Overview:\n<|{data}|chart|type=lines|x=TIME|y=HUMIDITY|color=Green|title=Humidity Overview|>"}
{"text": "# Display Temperature in Red and Humidity in Yellow against Time:\n<|{data}|chart|type=lines|x=TIME|y[1]=TEMPERATURE|y[2]=HUMIDITY|color[1]=Red|color[2]=Yellow|>"}
{"text": "# Visualize Humidity against Time in a Red dashed line and Temperature in a Yellow Dotted line:\n<|{data}|chart|type=lines|x=TIME|y[1]=HUMIDITY|y[2]=TEMPERATURE|line[1]=dash|line[2]=dot|color[1]=Red|color[2]=Yellow|>"}
{"text": "# Highlight Time according to Temperature:\n<|{data}|chart|type=lines|x=TIME|y=TEMPERATURE|>"}
{"text": "# Depict in a bar chart the Temperature against Time:\n<|{data}|chart|type=bar|x=TIME|y=TEMPERATURE|>"}
{"text": "# Depict in a bar chart the Temperature against Time and Humidity against Time:\n<|{data}|chart|type=bar|x=TIME|y[1]=TEMPERATURE|y[2]=HUMIDITY|>"}
{"text": "# Showcase Temperature and Humidity against Time in a bar chart:\n<|{data}|chart|type=bar|x=TIME|y[1]=TEMPERATURE|y[2]=HUMIDITY|>"}
{"text": "# Depict in a bar chart the Temperature against Time and Humidity against Time titled Climate Overview:\n<|{data}|chart|type=bar|x=TIME|y[1]=TEMPERATURE|y[2]=HUMIDITY|title=Climate Overview|>"}
{"text": "# Depict in a scatter plot Temperature against Time:\n<|{data}|chart|type=scatter|mode=markers|x=TIME|y=TEMPERATURE|>"}
{"text": "# Illustrate Temperature and Humidity against Time in a scatter plot:\n<|{data}|chart|type=scatter|mode=markers|x=TIME|y[1]=TEMPERATURE|y[2]=HUMIDITY|>"}
{"text": "# Plot Humidity in Green points and Temperature in Yellow points against Time:\n<|{data}|chart|type=scatter|mode=markers|x=TIME|y[1]=HUMIDITY|y[2]=TEMPERATURE|color[1]=Green|color[2]=Yellow|>"}
{"text": "# Display a histogram of Temperature:\n<|{data}|chart|type=histogram|x=TEMPERATURE|>"}
{"text": "# Showcase a horizontal histogram of Temperature:\n<|{data}|chart|type=histogram|x=TEMPERATURE|>"}
{"text": "# Illustrate the distribution of Temperature and Humidity:\n<|{data}|chart|type=histogram|x[1]=TEMPERATURE|x[2]=HUMIDITY|>"}
{"text": "# Illustrate the distribution of Temperature and Humidity titled \"Temperature and Humidity Distribution\":\n<|{data}|chart|type=histogram|x[1]=TEMPERATURE|x[2]=HUMIDITY|title=Temperature and Humidity Distribution|>"}
{"text": "# Present a horizontal distribution of Temperature and Humidity titled \"Temperature and Humidity Distribution\":\n<|{data}|chart|type=histogram|y[1]=TEMPERATURE|y[2]=HUMIDITY|title=Temperature and Humidity Distribution|>"}
{"text": "# Depict a pie chart of Temperature against Time:\n<|{data}|chart|type=pie|values=TEMPERATURE|labels=Time|>"}
{"text": "# Illustrate a pie chart of Temperature against Time titled \"Temperature Pie Chart\":\n<|{data}|chart|type=pie|values=TEMPERATURE|labels=Time|title=Temperature Pie Chart|>"}
{"text": "# Depict a pie chart of Humidity against Time:\n<|{data}|chart|type=pie|values=HUMIDITY|labels=Time|>"}
{"text": "# Plot Sales against Region in a line chart:\n<|{data}|chart|type=lines|x=REGION|y=SALES|>"}
{"text": "# Showcase Sales against Region in a line chart titled \"Sales by Region\":\n<|{data}|chart|type=lines|x=REGION|y=SALES|title=Sales by Region|>"}
{"text": "# Depict Sales and Profit against Region:\n<|{data}|chart|type=lines|x=REGION|y[1]=SALES|y[2]=PROFIT|>"}
{"text": "# Illustrate Sales against Region with a Dashed line:\n<|{data}|chart|type=lines|x=REGION|y=SALES|line=dash|>"}
{"text": "# Present Profit by Region on a Dotted line:\n<|{data}|chart|type=lines|x=REGION|y=PROFIT|line=dot|>"}
{"text": "# Plot Sales against Region in Blue:\n<|{data}|chart|type=lines|x=REGION|y=SALES|color=Blue|>"}
{"text": "# Exhibit Profit against Region in Green:\n<|{data}|chart|type=lines|x=REGION|y=PROFIT|color=Green|>"}
{"text": "# Show Profit against Region in Green titled Profit Overview:\n<|{data}|chart|type=lines|x=REGION|y=PROFIT|color=Green|title=Profit Overview|>"}
{"text": "# Display Sales in Red and Profit in Yellow against Region:\n<|{data}|chart|type=lines|x=REGION|y[1]=SALES|y[2]=PROFIT|color[1]=Red|color[2]=Yellow|>"}
{"text": "# Visualize Profit by Region in a Red dashed line and Sales in a Yellow Dotted line:\n<|{data}|chart|type=lines|x=REGION|y[1]=PROFIT|y[2]=SALES|line[1]=dash|line[2]=dot|color[1]=Red|color[2]=Yellow|>"}
{"text": "# Highlight Region according to Sales:\n<|{data}|chart|type=lines|x=REGION|y=SALES|>"}
{"text": "# Depict in a bar chart the Sales against Region:\n<|{data}|chart|type=bar|x=REGION|y=SALES|>"}
{"text": "# Depict in a bar chart the Sales against Region and Profit against Region:\n<|{data}|chart|type=bar|x=REGION|y[1]=SALES|y[2]=PROFIT|>"}
{"text": "# Showcase Sales and Profit against Region in a bar chart:\n<|{data}|chart|type=bar|x=REGION|y[1]=SALES|y[2]=PROFIT|>"}
{"text": "# Depict in a bar chart the Sales against Region and Profit against Region titled Financial Overview:\n<|{data}|chart|type=bar|x=REGION|y[1]=SALES|y[2]=PROFIT|title=Financial Overview|>"}
{"text": "# Depict in a scatter plot Sales against Region:\n<|{data}|chart|type=scatter|mode=markers|x=REGION|y=SALES|>"}
{"text": "# Illustrate Sales and Profit against Region in a scatter plot:\n<|{data}|chart|type=scatter|mode=markers|x=REGION|y[1]=SALES|y[2]=PROFIT|>"}
{"text": "# Plot Profit in Green points and Sales in Yellow points against Region:\n<|{data}|chart|type=scatter|mode=markers|x=REGION|y[1]=PROFIT|y[2]=SALES|color[1]=Green|color[2]=Yellow|>"}
{"text": "# Display a histogram of Sales against Region:\n<|{data}|chart|type=histogram|x=SALES|>"}
{"text": "# Showcase a horizontal histogram of Sales against Region:\n<|{data}|chart|type=histogram|x=SALES|>"}
{"text": "# Illustrate the distribution of Sales and Profit against Region:\n<|{data}|chart|type=histogram|x[1]=SALES|x[2]=PROFIT|>"}
{"text": "# Illustrate the distribution of Sales and Profit against Region titled \"Sales and Profit Distribution\":\n<|{data}|chart|type=histogram|x[1]=SALES|x[2]=PROFIT|title=Sales and Profit Distribution|>"}
{"text": "# Present a horizontal distribution of Sales and Profit against Region titled \"Sales and Profit Distribution\":\n<|{data}|chart|type=histogram|y[1]=SALES|y[2]=PROFIT|title=Sales and Profit Distribution|>"}
{"text": "# Depict a pie chart of Sales against Region:\n<|{data}|chart|type=pie|values=SALES|labels=Region|>"}
{"text": "# Illustrate a pie chart of Sales against Region titled \"Sales Pie Chart\":\n<|{data}|chart|type=pie|values=SALES|labels=Region|title=Sales Pie Chart|>"}
{"text": "# Depict a pie chart of Profit against Region:\n<|{data}|chart|type=pie|values=PROFIT|labels=Region|>"}
{"text": "# Visualize Productivity against Employee in a line chart:\n<|{data}|chart|type=lines|x=EMPLOYEE|y=PRODUCTIVITY|>"}
{"text": "# Showcase Productivity against Employee in a line chart titled \"Employee Productivity Trend\":\n<|{data}|chart|type=lines|x=EMPLOYEE|y=PRODUCTIVITY|title=Employee Productivity Trend|>"}
{"text": "# Depict Productivity and Satisfaction against Employee:\n<|{data}|chart|type=lines|x=EMPLOYEE|y[1]=PRODUCTIVITY|y[2]=SATISFACTION|>"}
{"text": "# Illustrate Productivity against Employee with a Dashed line:\n<|{data}|chart|type=lines|x=EMPLOYEE|y=PRODUCTIVITY|line=dash|>"}
{"text": "# Present Satisfaction by Employee on a Dotted line:\n<|{data}|chart|type=lines|x=EMPLOYEE|y=SATISFACTION|line=dot|>"}
{"text": "# Plot Productivity against Employee in Blue:\n<|{data}|chart|type=lines|x=EMPLOYEE|y=PRODUCTIVITY|color=Blue|>"}
{"text": "# Exhibit Satisfaction against Employee in Green:\n<|{data}|chart|type=lines|x=EMPLOYEE|y=SATISFACTION|color=Green|>"}
{"text": "# Show Satisfaction against Employee in Green titled Satisfaction Overview:\n<|{data}|chart|type=lines|x=EMPLOYEE|y=SATISFACTION|color=Green|title=Satisfaction Overview|>"}
{"text": "# Display Productivity in Red and Satisfaction in Yellow against Employee:\n<|{data}|chart|type=lines|x=EMPLOYEE|y[1]=PRODUCTIVITY|y[2]=SATISFACTION|color[1]=Red|color[2]=Yellow|>"}
{"text": "# Visualize Satisfaction by Employee in a Red dashed line and Productivity in a Yellow Dotted line:\n<|{data}|chart|type=lines|x=EMPLOYEE|y[1]=SATISFACTION|y[2]=PRODUCTIVITY|line[1]=dash|line[2]=dot|color[1]=Red|color[2]=Yellow|>"}
{"text": "# Highlight Employee according to Productivity:\n<|{data}|chart|type=lines|x=EMPLOYEE|y=PRODUCTIVITY|>"}
{"text": "# Depict in a bar chart the Productivity against Employee:\n<|{data}|chart|type=bar|x=EMPLOYEE|y=PRODUCTIVITY|>"}
{"text": "# Depict in a bar chart the Productivity against Employee and Satisfaction against Employee:\n<|{data}|chart|type=bar|x=EMPLOYEE|y[1]=PRODUCTIVITY|y[2]=SATISFACTION|>"}
{"text": "# Showcase Productivity and Satisfaction against Employee in a bar chart:\n<|{data}|chart|type=bar|x=EMPLOYEE|y[1]=PRODUCTIVITY|y[2]=SATISFACTION|>"}
{"text": "# Depict in a bar chart the Productivity against Employee and Satisfaction against Employee titled Work Overview:\n<|{data}|chart|type=bar|x=EMPLOYEE|y[1]=PRODUCTIVITY|y[2]=SATISFACTION|title=Work Overview|>"}
{"text": "# Depict in a scatter plot Productivity against Employee:\n<|{data}|chart|type=scatter|mode=markers|x=EMPLOYEE|y=PRODUCTIVITY|>"}
{"text": "# Illustrate Productivity and Satisfaction against Employee in a scatter plot:\n<|{data}|chart|type=scatter|mode=markers|x=EMPLOYEE|y[1]=PRODUCTIVITY|y[2]=SATISFACTION|>"}
{"text": "# Plot Satisfaction in Green points and Productivity in Yellow points against Employee:\n<|{data}|chart|type=scatter|mode=markers|x=EMPLOYEE|y[1]=SATISFACTION|y[2]=PRODUCTIVITY|color[1]=Green|color[2]=Yellow|>"}
{"text": "# Display a histogram of Productivity against Employee:\n<|{data}|chart|type=histogram|x=PRODUCTIVITY|>"}
{"text": "# Showcase a horizontal histogram of Productivity against Employee:\n<|{data}|chart|type=histogram|x=PRODUCTIVITY|>"}
{"text": "# Illustrate the distribution of Productivity and Satisfaction against Employee:\n<|{data}|chart|type=histogram|x[1]=PRODUCTIVITY|x[2]=SATISFACTION|>"}
{"text": "# Illustrate the distribution of Productivity and Satisfaction against Employee titled \"Productivity and Satisfaction Distribution\":\n<|{data}|chart|type=histogram|x[1]=PRODUCTIVITY|x[2]=SATISFACTION|title=Productivity and Satisfaction Distribution|>"}
{"text": "# Present a horizontal distribution of Productivity and Satisfaction against Employee titled \"Productivity and Satisfaction Distribution\":\n<|{data}|chart|type=histogram|y[1]=PRODUCTIVITY|y[2]=SATISFACTION|title=Productivity and Satisfaction Distribution|>"}
{"text": "# Depict a pie chart of Productivity against Employee:\n<|{data}|chart|type=pie|values=PRODUCTIVITY|labels=Employee|>"}
{"text": "# Illustrate a pie chart of Productivity against Employee titled \"Productivity Pie Chart\":\n<|{data}|chart|type=pie|values=PRODUCTIVITY|labels=Employee|title=Productivity Pie Chart|>"}
{"text": "# Depict a pie chart of Satisfaction against Employee:\n<|{data}|chart|type=pie|values=SATISFACTION|labels=Employee|>"}
{"text": "# Plot Population against Country in a line chart:\n<|{data}|chart|type=lines|x=COUNTRY|y=POPULATION|>"}
{"text": "# Showcase Population against Country in a line chart titled \"Population Trends\":\n<|{data}|chart|type=lines|x=COUNTRY|y=POPULATION|title=Population Trends|>"}
{"text": "# Depict Population and GDP against Country:\n<|{data}|chart|type=lines|x=COUNTRY|y[1]=POPULATION|y[2]=GDP|>"}
{"text": "# Illustrate Population against Country with a Dashed line:\n<|{data}|chart|type=lines|x=COUNTRY|y=POPULATION|line=dash|>"}
{"text": "# Present GDP by Country on a Dotted line:\n<|{data}|chart|type=lines|x=COUNTRY|y=GDP|line=dot|>"}
{"text": "# Plot Population against Country in Blue:\n<|{data}|chart|type=lines|x=COUNTRY|y=POPULATION|color=Blue|>"}
{"text": "# Exhibit GDP against Country in Green:\n<|{data}|chart|type=lines|x=COUNTRY|y=GDP|color=Green|>"}
{"text": "# Show GDP against Country in Green titled GDP Overview:\n<|{data}|chart|type=lines|x=COUNTRY|y=GDP|color=Green|title=GDP Overview|>"}
{"text": "# Display Population in Red and GDP in Yellow against Country:\n<|{data}|chart|type=lines|x=COUNTRY|y[1]=POPULATION|y[2]=GDP|color[1]=Red|color[2]=Yellow|>"}
{"text": "# Visualize GDP by Country in a Red dashed line and Population in a Yellow Dotted line:\n<|{data}|chart|type=lines|x=COUNTRY|y[1]=GDP|y[2]=POPULATION|line[1]=dash|line[2]=dot|color[1]=Red|color[2]=Yellow|>"}
{"text": "# Highlight Country according to Population:\n<|{data}|chart|type=lines|x=COUNTRY|y=POPULATION|>"}
{"text": "# Depict in a bar chart the Population against Country:\n<|{data}|chart|type=bar|x=COUNTRY|y=POPULATION|>"}
{"text": "# Depict in a bar chart the Population against Country and GDP against Country:\n<|{data}|chart|type=bar|x=COUNTRY|y[1]=POPULATION|y[2]=GDP|>"}
{"text": "# Showcase Population and GDP against Country in a bar chart:\n<|{data}|chart|type=bar|x=COUNTRY|y[1]=POPULATION|y[2]=GDP|>"}
{"text": "# Depict in a bar chart the Population against Country and GDP against Country titled Economic Overview:\n<|{data}|chart|type=bar|x=COUNTRY|y[1]=POPULATION|y[2]=GDP|title=Economic Overview|>"}
{"text": "# Depict in a scatter plot Population against Country:\n<|{data}|chart|type=scatter|mode=markers|x=COUNTRY|y=POPULATION|>"}
{"text": "# Illustrate Population and GDP against Country in a scatter plot:\n<|{data}|chart|type=scatter|mode=markers|x=COUNTRY|y[1]=POPULATION|y[2]=GDP|>"}
{"text": "# Plot GDP in Green points and Population in Yellow points against Country:\n<|{data}|chart|type=scatter|mode=markers|x=COUNTRY|y[1]=GDP|y[2]=POPULATION|color[1]=Green|color[2]=Yellow|>"}
{"text": "# Display a histogram of Population against Country:\n<|{data}|chart|type=histogram|x=POPULATION|>"}
{"text": "# Showcase a horizontal histogram of Population against Country:\n<|{data}|chart|type=histogram|x=POPULATION|>"}
{"text": "# Illustrate the distribution of Population and GDP against Country:\n<|{data}|chart|type=histogram|x[1]=POPULATION|x[2]=GDP|>"}
{"text": "# Illustrate the distribution of Population and GDP against Country titled \"Population and GDP Distribution\":\n<|{data}|chart|type=histogram|x[1]=POPULATION|x[2]=GDP|title=Population and GDP Distribution|>"}
{"text": "# Present a horizontal distribution of Population and GDP against Country titled \"Population and GDP Distribution\":\n<|{data}|chart|type=histogram|y[1]=POPULATION|y[2]=GDP|title=Population and GDP Distribution|>"}
{"text": "# Depict a pie chart of Population against Country:\n<|{data}|chart|type=pie|values=POPULATION|labels=Country|>"}
{"text": "# Illustrate a pie chart of Population against Country titled \"Population Pie Chart\":\n<|{data}|chart|type=pie|values=POPULATION|labels=Country|title=Population Pie Chart|>"}
{"text": "# Depict a pie chart of GDP against Country:\n<|{data}|chart|type=pie|values=GDP|labels=Country|>"}
{"text": "# **Worldwide**{: .color-primary} Health and Fitness Trends\n\n<br/>\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Average Life Expectancy**{: .color-primary}\n<|{'{:.1f}'.format(np.average(data_world_health['Life Expectancy']))}|text|class_name=h2|>\n|>\n\n<|card|\n**Obesity Rate**{: .color-primary}\n<|{'{:.2f}%'.format(np.average(data_world_health['Obesity Rate']))}|text|class_name=h2|>\n|>\n\n<|part|class_name=card|\n**Gym Memberships**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_world_health['Gym Memberships']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|{selected_health_metric}|toggle|lov={health_metric_selector}|>\n\n<|part|render={selected_health_metric=='Absolute'}|\n<|layout|columns=1 2|\n<|{data_world_health_pie_absolute}|chart|type=pie|labels=Country|values=Life Expectancy|title=Global Life Expectancy Distribution|>\n\n<|{data_world_health_evolution_absolute}|chart|properties={data_world_health_evolution_properties}|title=Health and Fitness Evolution Worldwide|>\n|>\n|>\n\n<|part|render={selected_health_metric=='Relative'}|\n<|layout|columns=1 2|\n<|{data_world_health_pie_relative}|chart|type=pie|labels=Country|values=Obesity Rate|>\n\n<|{data_world_health_evolution_relative}|chart|properties={data_world_health_evolution_relative_properties}|>\n|>\n|>\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\n\n# Load task data\ntask_data = pd.read_csv(\"task_data.csv\")\n\n# Initialize variables\npriorities = list(task_data[\"Priority\"].unique())\ncategories = list(task_data[\"Category\"].unique())\npriority = priorities\ncategory = categories\n\n# Markdown for the entire page\npage = \"\"\"<|toggle|theme|>\n\n<|layout|columns=20 80|gap=30px|\n<sidebar|\n## **Filter**{: .orange} Tasks:\n\n<|{priority}|selector|lov={priorities}|multiple|label=Select Priority|dropdown|on_change=on_filter|width=100%|>\n\n<|{category}|selector|lov={categories}|multiple|label=Select Category|dropdown|on_change=on_filter|width=100%|>\n|sidebar>\n\n<main_page|\n# Task Management System\n\n<|layout|columns=1 1 1|\n<total_tasks|\n## Total Tasks:\n### <|{len(df_selection)}|>\n|total_tasks>\n\n<average_completion_time|\n## Average Completion Time:\n### <|{round(df_selection[\"Completion Time\"].mean(), 2)}|> hours\n|average_completion_time>\n\n<task_table|\nDisplay df_selection in an expandable\n<|Task Table|expandable|expanded=False|\n<|{df_selection}|table|width=100%|page_size=10|rebuild|class_name=table|>\n|task_table>\n|main_page>\n|>\n\nCode adapted from [Task Management](https://github.com/task_management_app)\n\nGet the Taipy Code [here](https://github.com/Avaiga/task-management-app)\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\nfrom PIL import Image\nimport io\n\nimage_data = None\nimage_path = \"\"\n\ndef image_upload(state):\n    if state.image_path:\n        with open(state.image_path, \"rb\") as file:\n            state.image_data = Image.open(io.BytesIO(file.read()))\n\nimage_page = \"\"\"\n<|{image_path}|file_selector|accept=image/*|on_action=image_upload|>\n<|{image_data}|image|>\n\"\"\"\n\nGui(image_page).run()\n"}
{"text": "<|{all_reservations}|table|columns={reservation_columns}|width='100%'|on_action={on_reservation_select}|style=reservation_style|>\n<|Create Reservation|button|on_action={open_create_reservation_dialog}|>\n<|Refresh Reservations|button|on_action={refresh_reservation_list}|>\n\n<|{show_create_reservation_dialog}|dialog|title=Create Reservation|\n<|{customer_name}|input|placeholder='Customer Name'|\n<|{reservation_date}|datetime_picker|>\n<|{table_number}|number_input|min=1|placeholder='Table Number'|\n<|Create|button|on_action={create_reservation}|>\n<|Cancel|button|on_action={close_create_reservation_dialog}|>\n|>\n\n<|{show_reservation_details}|pane|\n\n# Reservation Details <|Edit|button|on_action=edit_selected_reservation|> <|Cancel|button|on_action=cancel_selected_reservation|>\n\n<|layout|columns=1|\n<|part|class_name=card|\n## Customer Name\n<|{selected_reservation.customer_name}|>\n|>\n\n<|part|class_name=card|\n## Date and Time\n<|{selected_reservation.date.strftime(\"%b %d, %Y at %H:%M\")}|>\n|>\n\n<|part|class_name=card|\n## Table Number\n<|{selected_reservation.table_number}|>\n|>\n\n----\n|>\n"}
{"text": "<|layout|columns=1 1|\n<|part|class_name=card|\n### Select Product Category<br/>\n<|{product_category_selected}|selector|lov=category_electronics;category_clothing;category_food|dropdown|on_change=on_product_category_change|>\n|>\n\n<|part|class_name=card|\n### Select Store Location<br/>\n<|{store_location_selected}|selector|lov=location_downtown;location_suburb;location_rural|dropdown|on_change=on_store_location_change|>\n|>\n\n|>\n\n<|Inventory Data Overview|expandable|expanded=True|\nDisplay category_data and location_data\n<|layout|columns=1 1|\n<|{category_data}|table|page_size=5|>\n\n<|{location_data}|table|page_size=5|>\n|>\n|>\n\n<|layout|columns=1 1|\n<|part|class_name=card|\n<|{stock_levels_chart}|chart|type=bar|x=Product|y=Stock Level|title=Stock Levels by Category|>\n|>\n\n<|part|class_name=card|\n<|{sales_by_location_chart}|chart|type=pie|options={sales_options}|layout={sales_layout}|title=Sales by Location|>\n|>\n|>\n\n<br/>\n### Analyze Inventory Efficiency:\n<|{inventory_efficiency_analysis}|scenario|on_submission_change=on_inventory_efficiency_status_change|expandable=False|expanded=False|>\n\n<|{inventory_efficiency_analysis}|scenario_dag|>\n\n<br/>\n### View inventory efficiency results:\n<|{inventory_efficiency_analysis.results if inventory_efficiency_analysis else None}|data_node|>\n"}
{"text": "from taipy import Gui\n\nimport numpy as np\nfrom PIL import Image\nimport matplotlib.pyplot as plt\n\nWINDOW_SIZE = 500\n\ncm = plt.cm.get_cmap(\"viridis\")\n\n\ndef generate_mandelbrot(\n    center: int = WINDOW_SIZE / 2,\n    dx_range: int = 1000,\n    dx_start: float = -0.12,\n    dy_range: float = 1000,\n    dy_start: float = -0.82,\n    iterations: int = 50,\n    max_value: int = 200,\n    i: int = 0,\n) -> str:\n    mat = np.zeros((WINDOW_SIZE, WINDOW_SIZE))\n    for y in range(WINDOW_SIZE):\n        for x in range(WINDOW_SIZE):\n            dx = (x - center) / dx_range + dx_start\n            dy = (y - center) / dy_range + dy_start\n            a = dx\n            b = dy\n            for t in range(iterations):\n                d = (a * a) - (b * b) + dx\n                b = 2 * (a * b) + dy\n                a = d\n                h = d > max_value\n                if h is True:\n                    mat[x, y] = t\n\n    colored_mat = cm(mat / mat.max())\n    im = Image.fromarray((colored_mat * 255).astype(np.uint8))\n    path = f\"mandelbrot_{i}.png\"\n    im.save(path)\n\n    return path\n\n\ndef generate(state):\n    state.i = state.i + 1\n    state.path = generate_mandelbrot(\n        dx_start=-state.dx_start / 100,\n        dy_start=(state.dy_start - 100) / 100,\n        iterations=state.iterations,\n        i=state.i,\n    )\n\n\ni = 0\ndx_start = 11\ndy_start = 17\niterations = 50\n\npath = generate_mandelbrot(\n    dx_start=-dx_start / 100,\n    dy_start=(dy_start - 100) / 100,\n)\n\npage = \"\"\"\n# Mandelbrot Art Generator\n\n<|layout|columns=35 65|\nDisplay Mandelbrot Art from path\n<|{path}|image|width=500px|height=500px|class_name=img|>\n\nIterations:<br />\nCreate a slider to select iterations\n<|{iterations}|slider|min=10|max=50|continuous=False|on_change=generate|><br />\nX Position:<br />\n<|{dy_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />\nY Position:<br />\n\nSlider dx_start\n<|{dx_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />\n|>\n\"\"\"\n\nGui(page).run(title=\"Mandelbrot Art Generator\")\n"}
{"text": "<|layout|columns=1 1|\n<|part|class_name=card|\n### Select Stock<br/>\n<|{stock_selected}|selector|lov=stock_apple;stock_google;stock_amazon|dropdown|on_change=on_stock_change|>\n|>\n\n<|part|class_name=card|\n### Select Comparison Market Index<br/>\n<|{market_index_selected}|selector|lov=index_nasdaq;index_s&p500;index_dowjones|dropdown|on_change=on_market_index_change|>\n|>\n\n|>\n\n<|Stock and Market Data|expandable|expanded=True|\nDisplay stock_data and market_index_data\n<|layout|columns=1 1|\n<|{stock_data}|table|page_size=5|>\n\n<|{market_index_data}|table|page_size=5|>\n|>\n|>\n\n<|layout|columns=1 1|\n<|part|class_name=card|\n<|{stock_price_chart}|chart|type=line|x=Date|y=Price|title=Stock Price Trend|>\n|>\n\n<|part|class_name=card|\n<|{market_index_chart}|chart|type=line|x=Date|y=Index Value|title=Market Index Trend|>\n|>\n|>\n\n<br/>\n### Run Financial Analysis:\n<|{financial_analysis}|scenario|on_submission_change=on_financial_analysis_status_change|expandable=False|expanded=False|>\n\n<|{financial_analysis}|scenario_dag|>\n\n<br/>\n### View financial analysis results:\n<|{financial_analysis.results if financial_analysis else None}|data_node|>\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\n\n# Load sales data\nsales_data = pd.read_csv(\"sales_data.csv\")\n\n# Initialize variables\nregions = list(sales_data[\"Region\"].unique())\nproducts = list(sales_data[\"Product\"].unique())\nregion = regions\nproduct = products\n\n# Markdown for the entire page\npage = \"\"\"<|toggle|theme|>\n\n<|layout|columns=20 80|gap=30px|\n<sidebar|\n## **Filter**{: .orange} Sales Data:\n\n<|{region}|selector|lov={regions}|multiple|label=Select Region|dropdown|on_change=on_filter|width=100%|>\n\n<|{product}|selector|lov={products}|multiple|label=Select Product|dropdown|on_change=on_filter|width=100%|>\n|sidebar>\n\n<main_page|\n# Sales Analysis Dashboard\n\n<|layout|columns=1 1 1|\n<total_sales|\n## Total Sales:\n### US $ <|{int(df_selection[\"Sales\"].sum())}|>\n|total_sales>\n\n<average_profit|\n## Average Profit:\n### US $ <|{round(df_selection[\"Profit\"].mean(), 2)}|>\n|average_profit>\n\n<sales_chart|\n<|{sales_by_month}|chart|x=Month|y=Sales|type=line|title=Sales by Month|color=#ff462b|width=100%|>\n\n<|{profit_chart}|chart|x=Month|y=Profit|type=line|title=Profit by Month|color=#ff462b|width=100%|>\n|sales_chart>\n|main_page>\n|>\n\nCode adapted from [Sales Analysis](https://github.com/sales_analysis_app)\n\nGet the Taipy Code [here](https://github.com/Avaiga/sales-analysis-app)\n"}
{"text": "<|{all_events}|table|columns={event_columns}|width='100%'|on_action={on_event_click}|style=event_style|>\n<|Create Event|button|on_action={open_create_event_dialog}|>\n<|Refresh Events|button|on_action={refresh_event_list}|>\n\n<|{show_create_event_dialog}|dialog|title=Create New Event|\n<|{event_title}|input|placeholder='Event Title'|\n<|{event_date}|date_picker|>\n<|Create Event|button|on_action={create_event}|>\n<|Cancel|button|on_action={close_create_event_dialog}|>\n|>\n\n<|{show_event_details}|pane|\n\n# Event Details <|Edit|button|on_action=edit_selected_event|> <|Cancel|button|on_action=cancel_selected_event|>\n\n<|layout|columns=1|\n<|part|class_name=card|\n## Title\n<|{selected_event.title}|>\n|>\n\n<|part|class_name=card|\n## Date\n<|{selected_event.date.strftime(\"%b %d, %Y\")}|>\n|>\n\n<|part|class_name=card|\n## Description\n<|{selected_event.description}|textarea|disabled=True|>\n|>\n\n----\n|>\n"}
{"text": "# **Country**{: .color-primary} Energy Consumption\n\n<|layout|columns=1 1 1|\n<|{selected_country_energy}|selector|lov={selector_country_energy}|on_change=on_change_country_energy|dropdown|label=Country|>\n\n<|{selected_energy_source}|toggle|lov={energy_source_selector}|on_change=update_energy_source_display|>\n|>\n\n<br/>\n\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Total Consumption**{: .color-primary}\n<|{'{:,}'.format(int(energy_data.iloc[-1]['Total']))}|text|class_name=h2|>\n|>\n\n<|card|\n**Renewable Sources**{: .color-primary}\n<|{'{:,}'.format(int(energy_data.iloc[-1]['Renewable']))}|text|class_name=h2|>\n|>\n\n<|card|\n**Non-Renewable Sources**{: .color-primary}\n<|{'{:,}'.format(int(energy_data.iloc[-1]['Non-Renewable']))}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|layout|columns=2 1|\n<|{energy_data}|chart|type=line|x=Year|y[3]=Total|y[2]=Renewable|y[1]=Non-Renewable|layout={layout}|options={options}|title=Energy Consumption Trends|>\n\n<|{energy_source_distribution_chart}|chart|type=pie|values=energy_source_values|labels=energy_source_labels|title=Energy Source Distribution|>\n|>\n"}
{"text": "<|{inventory_items}|table|columns={inventory_columns}|width='100%'|on_action={on_inventory_item_select}|style=inventory_style|>\n<|Add Item|button|on_action={open_add_item_dialog}|>\n<|Refresh Inventory|button|on_action={refresh_inventory}|>\n\n<|{show_add_item_dialog}|dialog|title=Add Inventory Item|\n<|{item_name}|input|placeholder='Item Name'|\n<|{item_quantity}|number_input|min=0|>\n<|Add Item|button|on_action={add_inventory_item}|>\n<|Cancel|button|on_action={close_add_item_dialog}|>\n|>\n\n<|{show_item_details}|pane|\n\n# Item Details <|Remove|button|on_action=remove_selected_item|> <|Update|button|on_action=update_selected_item|>\n\n<|layout|columns=2|\n<|part|class_name=card|\n## Name\n<|{selected_item.name}|>\n|>\n\n<|part|class_name=card|\n## Quantity\n<|{selected_item.quantity}|>\n|>\n\n<|part|class_name=card|\n## ID\n<|{selected_item.id}|>\n|>\n\n<|part|class_name=card|\n## Last Updated\n<|{selected_item.last_updated.strftime(\"%b %d, %Y at %H:%M:%S\")}|>\n|>\n\n----\n|>\n"}
{"text": "if __name__ == \"__main__\":\n    # Initialize with custom sector-related values\n    topic = \"Technology\"\n    mood = \"tech\"\n    style = \"techexpert\"\n\n    # Create a GUI page with custom settings\n    page = \"\"\"\n    <|container|\n    # **Generate**{: .color-primary} Technology Tweets\n\n    This mini-app generates Tweets related to Technology 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    <br/>\n\n    <|layout|columns=1 1 1|gap=30px|class_name=card|\n    <topic|\n    ## **Topic**{: .color-primary} (or hashtag)\n\n    <|{topic}|input|label=Technology Topic (or hashtag)|>\n    |topic>\n\n    <mood|\n    ## **Mood**{: .color-primary}\n\n    <|{mood}|input|label=Mood (e.g. tech, innovation, gadgets) (optional)|>\n    |mood>\n\n    <style|\n    ## Twitter **account**{: .color-primary}\n\n    <|{style}|input|label=Twitter account handle to style-copy recent Tech Tweets (optional)|>\n    |style>\n\n    Create a Generate text button\n    <|Generate Tech Tweet|button|on_action=generate_text|label=Generate text|>\n\n    <image|part|render={prompt != \"\" and tweet != \"\" and image is not None}|class_name=card|\n    ### **Image**{: .color-primary} for Technology\n\n    Display image\n    <center><|{image}|image|height=400px|></center>\n    |image>\n\n    Break line\n    <br/>\n\n    **Code from [@kinosal](https://twitter.com/kinosal)**\n\n    Original code can be found [here](https://github.com/kinosal/tweet)\n    |>\n    \"\"\"\n\n    Gui(page).run(dark_mode=False, port=5089)\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\n\n# Load event registration data\nevent_data = pd.read_csv(\"event_registration_data.csv\")\n\n# Initialize variables\nevents = list(event_data[\"Event\"].unique())\nregistrants = list(event_data[\"Registrant\"].unique())\nevent = events\nregistrant = registrants\n\n# Markdown for the entire page\npage = \"\"\"<|toggle|theme|>\n\n<|layout|columns=20 80|gap=30px|\n<sidebar|\n## **Filter**{: .orange} Event Registration:\n\n<|{event}|selector|lov={events}|multiple|label=Select Event|dropdown|on_change=on_filter|width=100%|>\n\n<|{registrant}|selector|lov={registrants}|multiple|label=Select Registrant|dropdown|on_change=on_filter|width=100%|>\n|sidebar>\n\n<main_page|\n# Event Registration System\n\n<|layout|columns=1 1 1|\n<total_registrations|\n## Total Registrations:\n### <|{len(df_selection)}|>\n|total_registrations>\n\n<average_attendance|\n## Average Attendance:\n### <|{round(df_selection[\"Attendance\"].mean(), 2)}|> attendees\n|average_attendance>\n\n<event_registration_table|\nDisplay df_selection in an expandable\n<|Event Registration Table|expandable|expanded=False|\n<|{df_selection}|table|width=100%|page_size=10|rebuild|class_name=table|>\n|event_registration_table>\n|main_page>\n|>\n\nCode adapted from [Event Registration](https://github.com/event_registration_app)\n\nGet the Taipy Code [here](https://github.com/Avaiga/event-registration-app)\n"}
{"text": "<|{all_courses}|table|columns={course_columns}|width='100%'|on_action={on_course_select}|style=course_style|>\n<|Add Course|button|on_action={open_add_course_dialog}|>\n<|Refresh Courses|button|on_action={refresh_course_list}|>\n\n<|{show_add_course_dialog}|dialog|title=Add New Course|\n<|{course_title}|input|placeholder='Course Title'|\n<|{course_instructor}|input|placeholder='Instructor Name'|\n<|{course_duration}|number_input|placeholder='Duration in Hours'|\n<|{course_category}|selector|lov={get_all_categories()}|>\n<|Add Course|button|on_action={add_course}|>\n<|Cancel|button|on_action={close_add_course_dialog}|>\n|>\n\n<|{show_course_details}|pane|\n\n# Course Details <|Edit|button|on_action=edit_selected_course|> <|Remove|button|on_action=remove_selected_course|>\n\n<|layout|columns=1|\n<|part|class_name=card|\n## Title\n<|{selected_course.title}|>\n|>\n\n<|part|class_name=card|\n## Instructor\n<|{selected_course.instructor}|>\n|>\n\n<|part|class_name=card|\n## Duration\n<|{selected_course.duration}|>\n|>\n\n<|part|class_name=card|\n## Category\n<|{selected_course.category}|>\n|>\n\n----\n|>\n"}
{"text": "<|{all_itineraries}|table|columns={itinerary_columns}|width='100%'|on_action={on_itinerary_select}|style=itinerary_style|>\n<|Create Itinerary|button|on_action={open_create_itinerary_dialog}|>\n<|Refresh Itineraries|button|on_action={refresh_itinerary_list}|>\n\n<|{show_create_itinerary_dialog}|dialog|title=Create Travel Itinerary|\n<|{destination}|input|placeholder='Destination'|\n<|{start_date}|date_picker|>\n<|{end_date}|date_picker|>\n<|Create Itinerary|button|on_action={create_itinerary}|>\n<|Cancel|button|on_action={close_create_itinerary_dialog}|>\n|>\n\n<|{show_itinerary_details}|pane|\n\n# Itinerary Details <|Edit|button|on_action=edit_selected_itinerary|> <|Remove|button|on_action=remove_selected_itinerary|>\n\n<|layout|columns=1|\n<|part|class_name=card|\n## Destination\n<|{selected_itinerary.destination}|>\n|>\n\n<|part|class_name=card|\n## Start Date\n<|{selected_itinerary.start_date.strftime(\"%b %d, %Y\")}|>\n|>\n\n<|part|class_name=card|\n## End Date\n<|{selected_itinerary.end_date.strftime(\"%b %d, %Y\")}|>\n|>\n\n----\n|>\n"}
{"text": "<|{all_exhibits}|table|columns={exhibit_columns}|width='100%'|on_action={on_exhibit_select}|style=exhibit_style|>\n<|Add Exhibit|button|on_action={open_add_exhibit_dialog}|>\n<|Refresh Exhibits|button|on_action={refresh_exhibit_list}|>\n\n<|{show_add_exhibit_dialog}|dialog|title=Add New Exhibit|\n<|{exhibit_name}|input|placeholder='Exhibit Name'|\n<|{exhibit_artist}|input|placeholder='Artist Name'|\n<|{exhibit_start_date}|date_picker|>\n<|{exhibit_end_date}|date_picker|>\n<|Add Exhibit|button|on_action={add_exhibit}|>\n<|Cancel|button|on_action={close_add_exhibit_dialog}|>\n|>\n\n<|{show_exhibit_details}|pane|\n\n# Exhibit Details <|Edit|button|on_action=edit_selected_exhibit|> <|Remove|button|on_action=remove_selected_exhibit|>\n\n<|layout|columns=1|\n<|part|class_name=card|\n## Name\n<|{selected_exhibit.name}|>\n|>\n\n<|part|class_name=card|\n## Artist\n<|{selected_exhibit.artist}|>\n|>\n\n<|part|class_name=card|\n## Start Date\n<|{selected_exhibit.start_date.strftime(\"%b %d, %Y\")}|>\n|>\n\n<|part|class_name=card|\n## End Date\n<|{selected_exhibit.end_date.strftime(\"%b %d, %Y\")}|>\n|>\n\n----\n|>\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\n\n# Load employee data\nemployee_data = pd.read_csv(\"employee_data.csv\")\n\n# Initialize variables\ndepartments = list(employee_data[\"Department\"].unique())\npositions = list(employee_data[\"Position\"].unique())\ndepartment = departments\nposition = positions\n\n# Markdown for the entire page\npage = \"\"\"<|toggle|theme|>\n\n<|layout|columns=20 80|gap=30px|\n<sidebar|\n## **Filter**{: .orange} Employees:\n\n<|{department}|selector|lov={departments}|multiple|label=Select Department|dropdown|on_change=on_filter|width=100%|>\n\n<|{position}|selector|lov={positions}|multiple|label=Select Position|dropdown|on_change=on_filter|width=100%|>\n|sidebar>\n\n<main_page|\n# Employee Management System\n\n<|layout|columns=1 1 1|\n<total_employees|\n## Total Employees:\n### <|{len(df_selection)}|>\n|total_employees>\n\n<average_salary|\n## Average Salary:\n### US $ <|{round(df_selection[\"Salary\"].mean(), 2)}|>\n|average_salary>\n\n<employee_table|\nDisplay df_selection in an expandable\n<|Employee Table|expandable|expanded=False|\n<|{df_selection}|table|width=100%|page_size=10|rebuild|class_name=table|>\n|employee_table>\n|main_page>\n|>\n\nCode adapted from [Employee Management](https://github.com/employee_management_app)\n\nGet the Taipy Code [here](https://github.com/Avaiga/employee-management-app)\n\"\"\"\n\ndef filter(department, position):\n    df_selection = employee_data[\n        employee_data[\"Department\"].isin(department)\n        & employee_data[\"Position\"].isin(position)\n    ]\n    return df_selection\n\ndef on_filter(state):\n    state.df_selection = filter(state.department, state.position)\n\nif __name__ == \"__main__\":\n    # Initialize dataframe\n    df_selection = filter(department, position)\n\n    # Run the app\n    Gui(page).run()\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\n\n# Load customer feedback data\nfeedback_data = pd.read_csv(\"customer_feedback_data.csv\")\n\n# Initialize variables\nproducts = list(feedback_data[\"Product\"].unique())\nratings = list(feedback_data[\"Rating\"].unique())\nproduct = products\nrating = ratings\n\n# Markdown for the entire page\npage = \"\"\"<|toggle|theme|>\n\n<|layout|columns=20 80|gap=30px|\n<sidebar|\n## **Filter**{: .orange} Customer Feedback:\n\n<|{product}|selector|lov={products}|multiple|label=Select Product|dropdown|on_change=on_filter|width=100%|>\n\n<|{rating}|selector|lov={ratings}|multiple|label=Select Rating|dropdown|on_change=on_filter|width=100%|>\n|sidebar>\n\n<main_page|\n# Customer Feedback System\n\n<|layout|columns=1 1 1|\n<total_feedback|\n## Total Feedback Entries:\n### <|{len(df_selection)}|>\n|total_feedback>\n\n<average_rating|\n## Average Rating:\n### <|{round(df_selection[\"Rating\"].mean(), 1)}|>\n|average_rating>\n\n<feedback_table|\nDisplay df_selection in an expandable\n<|Feedback Table|expandable|expanded=False|\n<|{df_selection}|table|width=100%|page_size=10|rebuild|class_name=table|>\n|feedback_table>\n|main_page>\n|>\n\nCode adapted from [Customer Feedback](https://github.com/customer_feedback_app)\n\nGet the Taipy Code [here](https://github.com/Avaiga/customer-feedback-app)\n"}
{"text": "from taipy.gui import Gui\nimport taipy as tp\n\n# Import pages related to the finance sector (replace with actual imports)\nfrom pages.finance.finance import finance_md\n\n# Define the pages\npages = {\n    '/': root,  # Replace with the root page if you have one\n    \"Finance\": finance_md,\n}\n\n# Create a Gui instance with the pages\ngui_multi_pages = Gui(pages=pages)\n\nif __name__ == '__main__':\n    tp.Core().run()\n\n    # Run the multi-page app\n    gui_multi_pages.run(title=\"Finance Dashboard\")\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\n\n# Load inventory data\ninventory_data = pd.read_csv(\"inventory_data.csv\")\n\n# Initialize variables\ncategories = list(inventory_data[\"Category\"].unique())\nlocations = list(inventory_data[\"Location\"].unique())\ncategory = categories\nlocation = locations\n\n# Markdown for the entire page\npage = \"\"\"<|toggle|theme|>\n\n<|layout|columns=20 80|gap=30px|\n<sidebar|\n## **Filter**{: .orange} Inventory Management:\n\n<|{category}|selector|lov={categories}|multiple|label=Select Category|dropdown|on_change=on_filter|width=100%|>\n\n<|{location}|selector|lov={locations}|multiple|label=Select Location|dropdown|on_change=on_filter|width=100%|>\n|sidebar>\n\n<main_page|\n# Inventory Management System\n\n<|layout|columns=1 1 1|\n<total_items|\n## Total Items:\n### <|{len(df_selection)}|>\n|total_items>\n\n<average_quantity|\n## Average Quantity:\n### <|{round(df_selection[\"Quantity\"].mean(), 2)}|> units\n|average_quantity>\n\n<inventory_table|\nDisplay df_selection in an expandable\n<|Inventory Table|expandable|expanded=False|\n<|{df_selection}|table|width=100%|page_size=10|rebuild|class_name=table|>\n|inventory_table>\n|main_page>\n|>\n\nCode adapted from [Inventory Management](https://github.com/inventory_management_app)\n\nGet the Taipy Code [here](https://github.com/Avaiga/inventory-management-app)\n"}
{"text": "<|layout|columns=2 9|gap=50px|\n<sidebar|sidebar|\n**Market Analysis** Setup\n\n<|{selected_market_analysis}|market_analysis_selector|>\n|sidebar>\n\n<market_analysis|part|render={selected_market_analysis}|\n# **Real Estate Trends**{: .color-primary} page\n\n<|1 1|layout|\n<date|\n#### Analysis **Start Date**{: .color-primary}\n\n<|{analysis_start_date}|date|on_change=on_change_market_analysis_params|>\n|date>\n\n<region|\n#### **Region**{: .color-primary} for Analysis\n\n<|{selected_region}|selector|lov={selector_region}|dropdown|on_change=on_change_market_analysis_params|label=Region|>\n|region>\n|>\n\n<|{selected_market_analysis}|market_analysis|on_submission_change=on_submission_change_market_analysis|not expanded|>\n\n---------------------------------------\n\n## **Market Predictions**{: .color-primary} and Data Exploration\n\n<|{selected_market_analysis.result.read() if selected_market_analysis and selected_market_analysis.result.read() is not None else default_market_result}|chart|x=Date|y[1]=Average Price|y[2]=Volume|y[3]=Trend Analysis|type[1]=line|title=Real Estate Market Trends|>\n\n<|Data Nodes|expandable|\n<|1 5|layout|\n<|{selected_data_node}|data_node_selector|> \n\n<|{selected_data_node}|data_node|>\n|>\n|>\n\n|market_analysis>\n|>\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\n\n# Load product inventory data\nproduct_inventory = pd.read_csv(\"product_inventory.csv\")\n\n# Initialize variables\ncategories = list(product_inventory[\"Category\"].unique())\nbrands = list(product_inventory[\"Brand\"].unique())\ncategory = categories\nbrand = brands\n\n# Markdown for the entire page\npage = \"\"\"<|toggle|theme|>\n\n<|layout|columns=20 80|gap=30px|\n<sidebar|\n## **Filter**{: .orange} Products:\n\n<|{category}|selector|lov={categories}|multiple|label=Select Category|dropdown|on_change=on_filter|width=100%|>\n\n<|{brand}|selector|lov={brands}|multiple|label=Select Brand|dropdown|on_change=on_filter|width=100%|>\n|sidebar>\n\n<main_page|\n# Product Inventory System\n\n<|layout|columns=1 1 1|\n<total_products|\n## Total Products:\n### <|{len(df_selection)}|>\n|total_products>\n\n<average_price|\n## Average Price:\n### US $ <|{round(df_selection[\"Price\"].mean(), 2)}|>\n|average_price>\n\n<product_table|\nDisplay df_selection in an expandable\n<|Product Table|expandable|expanded=False|\n<|{df_selection}|table|width=100%|page_size=10|rebuild|class_name=table|>\n|product_table>\n|main_page>\n|>\n\nCode adapted from [Product Inventory](https://github.com/product_inventory_app)\n\nGet the Taipy Code [here](https://github.com/Avaiga/product-inventory-app)\n"}
{"text": "# **Country**{: .color-primary} Agricultural Production\n\n<|layout|columns=1 1 1|\n<|{selected_country_agriculture}|selector|lov={selector_country_agriculture}|on_change=on_change_country_agriculture|dropdown|label=Country|>\n\n<|{selected_crop}|toggle|lov={crop_selector}|on_change=update_crop_display|>\n|>\n\n<br/>\n\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Total Production**{: .color-primary}\n<|{'{:,}'.format(int(agriculture_data.iloc[-1]['Total']))}|text|class_name=h2|>\n|>\n\n<|card|\n**Crop Yield**{: .color-primary}\n<|{'{:,}'.format(int(agriculture_data.iloc[-1]['Yield']))}|text|class_name=h2|>\n|>\n\n<|card|\n**Export Volume**{: .color-primary}\n<|{'{:,}'.format(int(agriculture_data.iloc[-1]['Export']))}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|layout|columns=2 1|\n<|{agriculture_data}|chart|type=area|x=Year|y[3]=Total|y[2]=Yield|y[1]=Export|layout={layout}|options={options}|title=Agricultural Trends|>\n\n<|{crop_distribution_chart}|chart|type=pie|values=crop_values|labels=crop_labels|title=Crop Distribution|>\n|>\n"}
{"text": "from taipy.gui import Gui\nimport taipy as tp\n\n# Import pages related to the e-commerce sector (replace with actual imports)\nfrom pages.ecommerce.ecommerce import ecommerce_md\n\n# Define the pages\npages = {\n    '/': root,  # Replace with the root page if you have one\n    \"E-commerce\": ecommerce_md,\n}\n\n# Create a Gui instance with the pages\ngui_multi_pages = Gui(pages=pages)\n\nif __name__ == '__main__':\n    tp.Core().run()\n\n    # Run the multi-page app\n    gui_multi_pages.run(title=\"E-commerce Dashboard\")\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\n\n# Load employee data\nemployee_data = pd.read_csv(\"employee_data.csv\")\n\n# Initialize variables\ndepartments = list(employee_data[\"Department\"].unique())\npositions = list(employee_data[\"Position\"].unique())\ndepartment = departments\nposition = positions\n\n# Markdown for the entire page\npage = \"\"\"<|toggle|theme|>\n\n<|layout|columns=20 80|gap=30px|\n<sidebar|\n## **Filter**{: .orange} Employees:\n\n<|{department}|selector|lov={departments}|multiple|label=Select Department|dropdown|on_change=on_filter|width=100%|>\n\n<|{position}|selector|lov={positions}|multiple|label=Select Position|dropdown|on_change=on_filter|width=100%|>\n|sidebar>\n\n<main_page|\n# Employee Management System\n\n<|layout|columns=1 1 1|\n<total_employees|\n## Total Employees:\n### <|{len(df_selection)}|>\n|total_employees>\n\n<average_salary|\n## Average Salary:\n### US $ <|{round(df_selection[\"Salary\"].mean(), 2)}|>\n|average_salary>\n\n<employee_table|\nDisplay df_selection in an expandable\n<|Employee Table|expandable|expanded=False|\n<|{df_selection}|table|width=100%|page_size=10|rebuild|class_name=table|>\n|employee_table>\n|main_page>\n|>\n\nCode adapted from [Employee Management](https://github.com/employee_management_app)\n\nGet the Taipy Code [here](https://github.com/Avaiga/employee-management-app)\n\"\"\"\n\ndef filter(department, position):\n    df_selection = employee_data[\n        employee_data[\"Department\"].isin(department)\n        & employee_data[\"Position\"].isin(position)\n    ]\n    return df_selection\n\ndef on_filter(state):\n    state.df_selection = filter(state.department, state.position)\n\nif __name__ == \"__main__\":\n    # Initialize dataframe\n    df_selection = filter(department, position)\n\n    # Run the app\n    Gui(page).run()\n"}
{"text": "<|{all_users}|table|columns={user_columns}|width='100%'|on_action={on_user_table_click}|style=user_style|>\n<|Add User|button|on_action={open_add_user_dialog}|>\n<|Refresh Users|button|on_action={refresh_user_list}|>\n\n<|{show_dialog_add_user}|dialog|title=Add new user|\n<|{new_user_name}|input|placeholder='Enter user name'|\n<|{new_user_role}|selector|lov={get_all_roles()}|>\n<|Add|button|on_action={add_user}|>\n<|Cancel|button|on_action={close_add_user_dialog}|>\n|>\n\n<|{show_user_details}|pane|\n\n# User Details <|Delete|button|on_action=delete_selected_user|> <|Disable|button|on_action=disable_selected_user|>\n\n<|layout|columns=1 1|\n<|part|class_name=card|\n## Name\n<|{selected_user.name}|>\n|>\n\n<|part|class_name=card|\n## Role\n<|{selected_user.role}|>\n|>\n\n<|part|class_name=card|\n## ID\n<|{selected_user.id}|>\n|>\n\n<|part|class_name=card|\n## Creation Date\n<|{selected_user.creation_date.strftime(\"%b %d %y %H:%M:%S\")}|>\n|>\n\n<|part|class_name=card|\n## Status\n<|{get_status(selected_user)}|>\n|>\n\n----\n|>\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\n\n# Load sales data\nsales_data = pd.read_csv(\"sales_data.csv\")\n\n# Initialize variables\nregions = list(sales_data[\"Region\"].unique())\ncategories = list(sales_data[\"Category\"].unique())\nregion = regions\ncategory = categories\n\n# Markdown for the entire page\npage = \"\"\"<|toggle|theme|>\n\n<|layout|columns=20 80|gap=30px|\n<sidebar|\n## **Filter**{: .orange} Sales Performance:\n\n<|{region}|selector|lov={regions}|multiple|label=Select Region|dropdown|on_change=on_filter|width=100%|>\n\n<|{category}|selector|lov={categories}|multiple|label=Select Category|dropdown|on_change=on_filter|width=100%|>\n|sidebar>\n\n<main_page|\n# Sales Performance Dashboard\n\n<|layout|columns=1 1 1|\n<total_sales|\n## Total Sales:\n### US $ <|{int(df_selection[\"Sales\"].sum())}|>\n|total_sales>\n\n<average_profit|\n## Average Profit:\n### US $ <|{round(df_selection[\"Profit\"].mean(), 2)}|>\n|average_profit>\n\n<sales_dashboard|\nDisplay df_selection in an expandable\n<|Sales Dashboard|expandable|expanded=False|\n<|{df_selection}|table|width=100%|page_size=10|rebuild|class_name=table|>\n|sales_dashboard>\n|main_page>\n|>\n\nCode adapted from [Sales Performance Dashboard](https://github.com/sales_performance_app)\n\nGet the Taipy Code [here](https://github.com/Avaiga/sales-performance-dashboard-app)\n"}
{"text": "<|{all_resources}|table|columns={resource_columns}|width='100%'|on_action={on_resource_select}|style=resource_style|>\n<|Allocate Resource|button|on_action={open_allocate_resource_dialog}|>\n<|Refresh Resources|button|on_action={refresh_resource_list}|>\n\n<|{show_allocate_resource_dialog}|dialog|title=Allocate Resource|\n<|{resource_name}|selector|lov={get_all_resources()}|>\n<|{resource_quantity}|number_input|min=0|placeholder='Quantity'|\n<|Allocate|button|on_action={allocate_resource}|>\n<|Cancel|button|on_action={close_allocate_resource_dialog}|>\n|>\n\n<|{show_resource_details}|pane|\n\n# Resource Details <|Release|button|on_action=release_selected_resource|> <|Update|button|on_action=update_selected_resource|>\n\n<|layout|columns=2|\n<|part|class_name=card|\n## Name\n<|{selected_resource.name}|>\n|>\n\n<|part|class_name=card|\n## Allocated Quantity\n<|{selected_resource.allocated_quantity}|>\n|>\n\n<|part|class_name=card|\n## Total Quantity\n<|{selected_resource.total_quantity}|>\n|>\n\n<|part|class_name=card|\n## Last Allocation Date\n<|{selected_resource.last_allocation_date.strftime(\"%b %d, %Y\")}|>\n|>\n\n----\n|>\n"}
{"text": "from taipy import Gui\nimport numpy as np\nfrom PIL import Image\nimport matplotlib.pyplot as plt\n\nWINDOW_SIZE = 500\n\ncm = plt.cm.get_cmap(\"viridis\")\n\n\ndef generate_mandelbrot(\n    center: int = WINDOW_SIZE / 2,\n    dx_range: int = 1000,\n    dx_start: float = -0.12,\n    dy_range: float = 1000,\n    dy_start: float = -0.82,\n    iterations: int = 50,\n    max_value: int = 200,\n    i: int = 0,\n) -> str:\n    mat = np.zeros((WINDOW_SIZE, WINDOW_SIZE))\n    for y in range(WINDOW_SIZE):\n        for x in range(WINDOW_SIZE):\n            dx = (x - center) / dx_range + dx_start\n            dy = (y - center) / dy_range + dy_start\n            a = dx\n            b = dy\n            for t in range(iterations):\n                d = (a * a) - (b * b) + dx\n                b = 2 * (a * b) + dy\n                a = d\n                h = d > max_value\n                if h is True:\n                    mat[x, y] = t\n\n    colored_mat = cm(mat / mat.max())\n    im = Image.fromarray((colored_mat * 255).astype(np.uint8))\n    path = f\"mandelbrot_{i}.png\"\n    im.save(path)\n\n    return path\n\n\ndef generate(state):\n    state.i = state.i + 1\n    state.path = generate_mandelbrot(\n        dx_start=-state.dx_start / 100,\n        dy_start=(state.dy_start - 100) / 100,\n        iterations=state.iterations,\n        i=state.i,\n    )\n\n\ni = 0\ndx_start = 11\ndy_start = 17\niterations = 50\n\npath = generate_mandelbrot(\n    dx_start=-dx_start / 100,\n    dy_start=(dy_start - 100) / 100,\n)\n\npage = \"\"\"\n# Mandelbrot Fractal Education\n\n<|layout|columns=35 65|\nDisplay Mandelbrot Fractal for Educational Purposes\n<|{path}|image|width=500px|height=500px|class_name=img|>\n\nIterations:<br />\nCreate a slider to select iterations\n<|{iterations}|slider|min=10|max=50|continuous=False|on_change=generate|><br />\nX Position:<br />\n<|{dy_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />\nY Position:<br />\n\nSlider dx_start\n<|{dx_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />\n|>\n\"\"\"\n\nGui(page).run(title=\"Mandelbrot Fractal Education\")\n"}
{"text": "if __name__ == \"__main__\":\n    # Initialize with custom sector-related values\n    topic = \"Economics\"\n    mood = \"economicanalysis\"\n    style = \"economicspro\"\n\n    # Create a GUI page with custom settings\n    page = \"\"\"\n    <|container|\n    # **Generate**{: .color-primary} Economics Tweets\n\n    This mini-app generates Tweets related to Economics 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    <br/>\n\n    <|layout|columns=1 1 1|gap=30px|class_name=card|\n    <topic|\n    ## **Topic**{: .color-primary} (or hashtag)\n\n    <|{topic}|input|label=Economics Topic (or hashtag)|>\n    |topic>\n\n    <mood|\n    ## **Mood**{: .color-primary}\n\n    <|{mood}|input|label=Mood (e.g. economicanalysis, finance, markets) (optional)|>\n    |mood>\n\n    <style|\n    ## Twitter **account**{: .color-primary}\n\n    <|{style}|input|label=Twitter account handle to style-copy recent Economics Tweets (optional)|>\n    |style>\n\n    Create a Generate text button\n    <|Generate Economics Tweet|button|on_action=generate_text|label=Generate text|>\n\n    <image|part|render={prompt != \"\" and tweet != \"\" and image is not None}|class_name=card|\n    ### **Image**{: .color-primary} for Economics\n\n    Display image\n    <center><|{image}|image|height=400px|></center>\n    |image>\n\n    Break line\n    <br/>\n\n    **Code from [@kinosal](https://twitter.com/kinosal)**\n\n    Original code can be found [here](https://github.com/kinosal/tweet)\n    |>\n    \"\"\"\n\n    Gui(page).run(dark_mode=False, port=5089)\n"}
{"text": "<|layout|columns=1 1|\n<|part|class_name=card|\n### Select Traffic Zone<br/>\n<|{traffic_zone_selected}|selector|lov=zone_downtown;zone_suburbs;zone_industrial|dropdown|on_change=on_traffic_zone_change|>\n|>\n\n<|part|class_name=card|\n### Select Time of Day<br/>\n<|{time_of_day_selected}|selector|lov=time_morning;time_afternoon;time_evening|dropdown|on_change=on_time_of_day_change|>\n|>\n\n|>\n\n<|Traffic Data Overview|expandable|expanded=True|\nDisplay traffic_zone_data and time_of_day_data\n<|layout|columns=1 1|\n<|{traffic_zone_data}|table|page_size=5|>\n\n<|{time_of_day_data}|table|page_size=5|>\n|>\n|>\n\n<|layout|columns=1 1|\n<|part|class_name=card|\n<|{traffic_volume_chart}|chart|type=bar|x=Zone|y=Traffic Volume|title=Traffic Volume by Zone|>\n|>\n\n<|part|class_name=card|\n<|{peak_hours_chart}|chart|type=line|x=Time|y=Vehicles|title=Peak Traffic Hours|>\n|>\n|>\n\n<br/>\n### Analyze Traffic Patterns:\n<|{traffic_pattern_analysis}|scenario|on_submission_change=on_traffic_pattern_status_change|expandable=False|expanded=False|>\n\n<|{traffic_pattern_analysis}|scenario_dag|>\n\n<br/>\n### View traffic pattern analysis results:\n<|{traffic_pattern_analysis.results if traffic_pattern_analysis else None}|data_node|>\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\n\ntext_data = \"\"\ntext_path = \"\"\n\ndef text_upload(state):\n    if state.text_path:\n        with open(state.text_path, \"r\") as file:\n            state.text_data = file.read()\n\ntext_page = \"\"\"\n<|{text_path}|file_selector|accept=.txt|on_action=text_upload|>\n<|{text_data}|textarea|rows=10|>\n\"\"\"\n\nGui(text_page).run()\n"}
{"text": "from taipy import Gui\nimport numpy as np\nfrom PIL import Image\nimport matplotlib.pyplot as plt\n\nWINDOW_SIZE = 500\n\ncm = plt.cm.get_cmap(\"viridis\")\n\n\ndef generate_mandelbrot(\n    center: int = WINDOW_SIZE / 2,\n    dx_range: int = 1000,\n    dx_start: float = -0.12,\n    dy_range: float = 1000,\n    dy_start: float = -0.82,\n    iterations: int = 50,\n    max_value: int = 200,\n    i: int = 0,\n) -> str:\n    mat = np.zeros((WINDOW_SIZE, WINDOW_SIZE))\n    for y in range(WINDOW_SIZE):\n        for x in range(WINDOW_SIZE):\n            dx = (x - center) / dx_range + dx_start\n            dy = (y - center) / dy_range + dy_start\n            a = dx\n            b = dy\n            for t in range(iterations):\n                d = (a * a) - (b * b) + dx\n                b = 2 * (a * b) + dy\n                a = d\n                h = d > max_value\n                if h is True:\n                    mat[x, y] = t\n\n    colored_mat = cm(mat / mat.max())\n    im = Image.fromarray((colored_mat * 255).astype(np.uint8))\n    path = f\"mandelbrot_{i}.png\"\n    im.save(path)\n\n    return path\n\n\ndef generate(state):\n    state.i = state.i + 1\n    state.path = generate_mandelbrot(\n        dx_start=-state.dx_start / 100,\n        dy_start=(state.dy_start - 100) / 100,\n        iterations=state.iterations,\n        i=state.i,\n    )\n\n\ni = 0\ndx_start = 11\ndy_start = 17\niterations = 50\n\npath = generate_mandelbrot(\n    dx_start=-dx_start / 100,\n    dy_start=(dy_start - 100) / 100,\n)\n\npage = \"\"\"\n# Mandelbrot Fractal for Agriculture Visualization\n\n<|layout|columns=35 65|\nVisualize Complex Patterns with Mandelbrot Fractals\n<|{path}|image|width=500px|height=500px|class_name=img|>\n\nIterations:<br />\nSelect the number of iterations to explore fractal patterns\n<|{iterations}|slider|min=10|max=50|continuous=False|on_change=generate|><br />\nX Position:<br />\n<|{dy_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />\nY Position:<br />\n\nSlider dx_start\n<|{dx_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />\n|>\n\"\"\"\n\nGui(page).run(title=\"Mandelbrot Fractal for Agriculture Visualization\")\n"}
{"text": "<|layout|columns=2 9|gap=50px|\n<sidebar|sidebar|\n**Demand Forecasting** Initialization\n\n<|{selected_demand_forecast}|demand_forecast_selector|>\n|sidebar>\n\n<demand_forecast|part|render={selected_demand_forecast}|\n# **Energy Demand Prediction**{: .color-primary} page\n\n<|1 1|layout|\n<date|\n#### Forecast **Target Date**{: .color-primary}\n\n<|{forecast_target_date}|date|on_change=on_change_demand_forecast_params|>\n|date>\n\n<energy_type|\n#### **Energy Type**{: .color-primary} for Forecasting\n\n<|{selected_energy_type}|selector|lov={selector_energy_type}|dropdown|on_change=on_change_demand_forecast_params|label=Energy Type|>\n|energy_type>\n|>\n\n<|{selected_demand_forecast}|demand_forecast|on_submission_change=on_submission_change_demand_forecast|not expanded|>\n\n---------------------------------------\n\n## **Energy Demand Projections**{: .color-primary} and Data Analysis\n\n<|{selected_demand_forecast.result.read() if selected_demand_forecast and selected_demand_forecast.result.read() is not None else default_demand_result}|chart|x=Date|y[1]=Projected Demand|y[2]=Historical Demand|type[1]=bar|title=Energy Demand Forecast|>\n\n<|Data Nodes|expandable|\n<|1 5|layout|\n<|{selected_data_node}|data_node_selector|> \n\n<|{selected_data_node}|data_node|>\n|>\n|>\n\n|demand_forecast>\n|>\n"}
{"text": "# **Country**{: .color-primary} Economic Indicators\n\n<|layout|columns=1 1 1|\n<|{selected_country_economy}|selector|lov={selector_country_economy}|on_change=on_change_country_economy|dropdown|label=Country|>\n\n<|{selected_economic_indicator}|toggle|lov={economic_indicator_selector}|on_change=update_economic_indicator|>\n|>\n\n<br/>\n\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**GDP**{: .color-primary}\n<|{'${:,.2f}'.format(economy_data.iloc[-1]['GDP'])}|text|class_name=h2|>\n|>\n\n<|card|\n**Inflation Rate**{: .color-primary}\n<|{'{:.2f}%'.format(economy_data.iloc[-1]['Inflation Rate'])}|text|class_name=h2|>\n|>\n\n<|card|\n**Unemployment Rate**{: .color-primary}\n<|{'{:.2f}%'.format(economy_data.iloc[-1]['Unemployment Rate'])}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|layout|columns=2 1|\n<|{economy_data}|chart|type=line|x=Year|y[3]=GDP|y[2]=Inflation Rate|y[1]=Un\n"}
{"text": "<|layout|columns=1 1|\n<|part|class_name=card|\n### Select Energy Source<br/>\n<|{energy_source_selected}|selector|lov=source_solar;source_wind;source_hydro|dropdown|on_change=on_energy_source_change|>\n|>\n\n<|part|class_name=card|\n### Select Region<br/>\n<|{region_selected}|selector|lov=region_north;region_south;region_east;region_west|dropdown|on_change=on_region_change|>\n|>\n\n|>\n\n<|Energy Data Overview|expandable|expanded=True|\nDisplay energy_data and region_data\n<|layout|columns=1 1|\n<|{energy_data}|table|page_size=5|>\n\n<|{region_data}|table|page_size=5|>\n|>\n|>\n\n<|layout|columns=1 1|\n<|part|class_name=card|\n<|{consumption_chart}|chart|type=bar|x=Month|y=Consumption|title=Energy Consumption by Source|>\n|>\n\n<|part|class_name=card|\n<|{region_comparison_chart}|chart|type=line|x=Month|y=Region Consumption|title=Regional Energy Consumption|>\n|>\n|>\n\n<br/>\n### Analyze Energy Trends:\n<|{energy_trend_analysis}|scenario|on_submission_change=on_energy_trend_status_change|expandable=False|expanded=False|>\n\n<|{energy_trend_analysis}|scenario_dag|>\n\n<br/>\n### View energy trend analysis results:\n<|{energy_trend_analysis.results if energy_trend_analysis else None}|data_node|>\n"}
{"text": "from taipy.gui import Gui\nimport taipy as tp\n\nfrom pages.country.country import country_md\nfrom pages.world.world import world_md\nfrom pages.map.map import map_md\nfrom pages.predictions.predictions import predictions_md, selected_scenario\nfrom pages.root import root, selected_country, selector_country\n\nfrom config.config import Config\n\n# Define the pages\npages = {\n    '/': root,\n    \"Country\": country_md,\n    \"World\": world_md,\n    \"Map\": map_md,\n    \"Predictions\": predictions_md\n}\n\n# Create a Gui instance with the pages\ngui_multi_pages = Gui(pages=pages)\n\nif __name__ == '__main__':\n    tp.Core().run()\n\n    # Run the multi-page app\n    gui_multi_pages.run(title=\"Covid Dashboard\")\n"}
{"text": "<|layout|columns=1 1|\n<|part|class_name=card|\n### Select Research Area<br/>\n<|{research_area_selected}|selector|lov=area_physics;area_chemistry;area_biology|dropdown|on_change=on_research_area_change|>\n|>\n\n<|part|class_name=card|\n### Select Year<br/>\n<|{publication_year_selected}|selector|lov=year_2020;year_2021;year_2022|dropdown|on_change=on_publication_year_change|>\n|>\n\n|>\n\n<|Research Publications Overview|expandable|expanded=True|\nDisplay research_data and year_data\n<|layout|columns=1 1|\n<|{research_data}|table|page_size=5|>\n\n<|{year_data}|table|page_size=5|>\n|>\n|>\n\n<|layout|columns=1 1|\n<|part|class_name=card|\n<|{publication_count_chart}|chart|type=bar|x=Research Area|y=Publications|title=Publications Count|>\n|>\n\n<|part|class_name=card|\n<|{citation_chart}|chart|type=line|x=Year|y=Citations|title=Citation Trends|>\n|>\n|>\n\n<br/>\n### Analyze Research Impact:\n<|{research_impact_analysis}|scenario|on_submission_change=on_research_impact_status_change|expandable=False|expanded=False|>\n\n<|{research_impact_analysis}|scenario_dag|>\n\n<br/>\n### View research impact results:\n<|{research_impact_analysis.results if research_impact_analysis else None}|data_node|>\n"}
{"text": "<|layout|columns=1 1|\n<|part|class_name=card|\n### Select Department<br/>\n<|{department_selected}|selector|lov=dept_sales;dept_marketing;dept_technical|dropdown|on_change=on_department_change|>\n|>\n\n<|part|class_name=card|\n### Select Time Period<br/>\n<|{time_period_selected}|selector|lov=period_this_month;period_last_month;period_this_quarter|dropdown|on_change=on_time_period_change|>\n|>\n\n|>\n\n<|Employee Performance Overview|expandable|expanded=True|\nDisplay department_data and time_period_data\n<|layout|columns=1 1|\n<|{department_data}|table|page_size=5|>\n\n<|{time_period_data}|table|page_size=5|>\n|>\n|>\n\n<|layout|columns=1 1|\n<|part|class_name=card|\n<|{performance_chart}|chart|type=bar|x=Employee|y=Performance Score|title=Department Performance|>\n|>\n\n<|part|class_name=card|\n<|{attendance_chart}|chart|type=line|options={attendance_options}|layout={attendance_layout}|>\n|>\n|>\n\n<br/>\n### Run Employee Analysis:\n<|{employee_analysis}|scenario|on_submission_change=on_employee_analysis_status_change|expandable=False|expanded=False|>\n\n<|{employee_analysis}|scenario_dag|>\n\n<br/>\n### View the employee analysis results:\n<|{employee_analysis.results if employee_analysis else None}|data_node|>\n"}
{"text": "from taipy.gui import Gui, notify, state\nimport random\nimport re\nimport logging\nimport taipy\n\n# Import OpenAI module\nimport oai\n\n# Configure logger\nlogging.basicConfig(format=\"\\n%(asctime)s\\n%(message)s\", level=logging.INFO, force=True)\n\n\n# Define functions\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\n\ndef error_too_many_requests(state):\n    \"\"\"Notify user that too many requests have been made.\"\"\"\n    notify(\n        state,\n        \"error\",\n        \"Too many requests. Please wait a few seconds before generating another text or image.\",\n    )\n    logging.info(f\"Session request limit reached: {state.n_requests}\")\n    state.n_requests = 1\n\n\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    # 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 = openai.complete(state.prompt).strip().replace('\"', \"\")\n\n        # Notify the user in console and in the GUI\n        logging.info(\n            f\"Topic: {state.prompt}{state.mood}{state.style}\\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(prompt=processing_prompt, temperature=0.5, max_tokens=40)\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\ndef feeling_lucky(state):\n    \"\"\"Generate a feeling-lucky tweet.\"\"\"\n    with open(\"moods.txt\") as f:\n        sample_moods = f.read().splitlines()\n    state.topic = \"an interesting topic\"\n    state.mood = random.choice(sample_moods)\n    state.style = \"\"\n    generate_text(state)\n\n\n# Variables\ntweet = \"\"\nprompt = \"\"\nn_requests = 0\n\ntopic = \"AI\"\nmood = \"inspirational\"\nstyle = \"elonmusk\"\n\nimage = None\n\n\n# Called whenever 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\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<br/>\n\n<|layout|columns=1 1 1|gap=30px|class_name=card|\n<topic|\n## **Topic**{: .color-primary} (or hashtag)\n\n<|{topic}|input|label=Topic (or hashtag)|>\n|topic>\n\n<mood|\n## **Mood**{: .color-primary}\n\n<|{mood}|input|label=Mood (e.g. inspirational, funny, serious) (optional)|>\n|mood>\n\n<style|\n## Twitter **account**{: .color-primary}\n\n<|{style}|input|label=Twitter account handle to style-copy recent Tweets (optional)|>\n|style>\n\nCreate a Generate text button\n<|Generate text|button|on_action=generate_text|label=Generate text|>\n\n<|Feeling lucky|button|on_action=feeling_lucky|label=Feeling Lucky|>\n|>\n\n<br/>\n\n---\n\n<br/>\n\n### Generated **Tweet**{: .color-primary}\n\nCreate a text input for the tweet\n<|{tweet}|input|multiline|label=Resulting tweet|class_name=fullwidth|\n"}
{"text": "from taipy import Gui\nimport numpy as np\nfrom PIL import Image\nimport matplotlib.pyplot as plt\n\nWINDOW_SIZE = 500\n\ncm = plt.cm.get_cmap(\"viridis\")\n\n\ndef generate_mandelbrot(\n    center: int = WINDOW_SIZE / 2,\n    dx_range: int = 1000,\n    dx_start: float = -0.12,\n    dy_range: float = 1000,\n    dy_start: float = -0.82,\n    iterations: int = 50,\n    max_value: int = 200,\n    i: int = 0,\n) -> str:\n    mat = np.zeros((WINDOW_SIZE, WINDOW_SIZE))\n    for y in range(WINDOW_SIZE):\n        for x in range(WINDOW_SIZE):\n            dx = (x - center) / dx_range + dx_start\n            dy = (y - center) / dy_range + dy_start\n            a = dx\n            b = dy\n            for t in range(iterations):\n                d = (a * a) - (b * b) + dx\n                b = 2 * (a * b) + dy\n                a = d\n                h = d > max_value\n                if h is True:\n                    mat[x, y] = t\n\n    colored_mat = cm(mat / mat.max())\n    im = Image.fromarray((colored_mat * 255).astype(np.uint8))\n    path = f\"mandelbrot_{i}.png\"\n    im.save(path)\n\n    return path\n\n\ndef generate(state):\n    state.i = state.i + 1\n    state.path = generate_mandelbrot(\n        dx_start=-state.dx_start / 100,\n        dy_start=(state.dy_start - 100) / 100,\n        iterations=state.iterations,\n        i=state.i,\n    )\n\n\ni = 0\ndx_start = 11\ndy_start = 17\niterations = 50\n\npath = generate_mandelbrot(\n    dx_start=-dx_start / 100,\n    dy_start=(dy_start - 100) / 100,\n)\n\npage = \"\"\"\n# Mandelbrot Fractal for Scientific Visualization\n\n<|layout|columns=35 65|\nVisualize Complex Patterns with Mandelbrot Fractals\n<|{path}|image|width=500px|height=500px|class_name=img|>\n\nIterations:<br />\nSelect the number of iterations to explore fractal patterns\n<|{iterations}|slider|min=10|max=50|continuous=False|on_change=generate|><br />\nX Position:<br />\n<|{dy_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />\nY Position:<br />\n\nSlider dx_start\n<|{dx_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />\n|>\n\"\"\"\n\nGui(page).run(title=\"Mandelbrot Fractal for Scientific Visualization\")\n"}
{"text": "from taipy.gui import Gui\nimport taipy as tp\n\n# Import pages related to the automotive sector (replace with actual imports)\nfrom pages.automotive.automotive import automotive_md\n\n# Define the pages\npages = {\n    '/': root,  # Replace with the root page if you have one\n    \"Automotive\": automotive_md,\n}\n\n# Create a Gui instance with the pages\ngui_multi_pages = Gui(pages=pages)\n\nif __name__ == '__main__':\n    tp.Core().run()\n\n    # Run the multi-page app\n    gui_multi_pages.run(title=\"Automotive Dashboard\")\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\nimport json\n\njson_data = []\njson_path = \"\"\n\ndef json_upload(state):\n    with open(state.json_path, 'r') as file:\n        state.json_data = pd.read_json(file)\n\njson_page = \"\"\"\n<|{json_path}|file_selector|accept=.json|on_action=json_upload|>\n<|{json_data}|table|>\n\"\"\"\n\nGui(json_page).run()\n"}
{"text": "<|layout|columns=1 1|\n<|part|class_name=card|\n### Select Primary City for Weather Data<br/>\n<|{primary_city_selected}|selector|lov=city_new_york;city_london;city_tokyo|dropdown|on_change=on_primary_city_change|>\n|>\n\n<|part|class_name=card|\n### Select City to Compare<br/>\n<|{compare_city_selected}|selector|lov=city_new_york;city_london;city_tokyo|dropdown|on_change=on_compare_city_change|>\n|>\n\n|>\n\n<|Weather Data Overview|expandable|expanded=True|\nDisplay primary_city_data and compare_city_data\n<|layout|columns=1 1|\n<|{primary_city_data}|table|page_size=5|>\n\n<|{compare_city_data}|table|page_size=5|>\n|>\n|>\n\n<|layout|columns=1 1|\n<|part|class_name=card|\n<|{temperature_chart}|chart|type=line|x=Day|y[1]=Primary City Temp|y[2]=Compare City Temp|title=Temperature Comparison|>\n|>\n\n<|part|class_name=card|\n<|{humidity_chart}|chart|type=bar|x=Day|y[1]=Primary City Humidity|y[2]=Compare City Humidity|title=Humidity Comparison|>\n|>\n|>\n\n<br/>\n### Analyze Weather Patterns:\n<|{weather_pattern_analysis}|scenario|on_submission_change=on_weather_pattern_status_change|expandable=False|expanded=False|>\n\n<|{weather_pattern_analysis}|scenario_dag|>\n\n<br/>\n### View weather analysis results:\n<|{weather_pattern_analysis.results if weather_pattern_analysis else None}|data_node|>\n"}
{"text": "from taipy.gui import Gui\nimport taipy as tp\n\n# Import pages for the logistics sector\nfrom pages.logistics.dashboard import dashboard_md\nfrom pages.logistics.orders import orders_md\nfrom pages.logistics.inventory import inventory_md\nfrom pages.logistics.shipping import shipping_md\n\n# Define your pages dictionary\npages = {\n    '/dashboard': dashboard_md,\n    '/orders': orders_md,\n    '/inventory': inventory_md,\n    '/shipping': shipping_md\n}\n\n# Create a Gui with your pages\ngui_logistics = Gui(pages=pages)\n\nif __name__ == '__main__':\n    tp.Core().run()\n    \n    # Run the multi-page app\n    gui_logistics.run(title=\"Logistics Dashboard\")\n"}
{"text": "<|{all_projects}|table|columns={project_columns}|width='100%'|on_action={on_project_table_click}|style=project_style|>\n<|Create Project|button|on_action={open_create_project_dialog}|>\n<|Refresh Projects|button|on_action={refresh_project_list}|>\n\n<|{show_dialog_create_project}|dialog|title=Create new project|\n<|{project_name}|input|placeholder='Enter project name'|\n<|Create|button|on_action={create_project}|>\n<|Cancel|button|on_action={close_create_project_dialog}|>\n|>\n\n<|{show_project_details}|pane|\n\n# Project Details <|Delete|button|on_action=delete_selected_project|> <|Archive|button|on_action=archive_selected_project|>\n\n<|layout|columns=1 1|\n<|part|class_name=card|\n## Project Name\n<|{selected_project.name}|>\n|>\n\n<|part|class_name=card|\n## Project Manager\n<|{selected_project.manager}|>\n|>\n\n<|part|class_name=card|\n## ID\n<|{selected_project.id}|>\n|>\n\n<|part|class_name=card|\n## Start Date\n<|{selected_project.start_date.strftime(\"%b %d %y\")}|>\n|>\n\n<|part|class_name=card|\n## Status\n<|{get_project_status(selected_project)}|>\n|>\n\n----\n|>\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\n\n# Load employee time tracking data\ntime_tracking_data = pd.read_csv(\"time_tracking_data.csv\")\n\n# Initialize variables\nemployees = list(time_tracking_data[\"Employee\"].unique())\nprojects = list(time_tracking_data[\"Project\"].unique())\nemployee = employees\nproject = projects\n\n# Markdown for the entire page\npage = \"\"\"<|toggle|theme|>\n\n<|layout|columns=20 80|gap=30px|\n<sidebar|\n## **Filter**{: .orange} Time Tracking:\n\n<|{employee}|selector|lov={employees}|multiple|label=Select Employee|dropdown|on_change=on_filter|width=100%|>\n\n<|{project}|selector|lov={projects}|multiple|label=Select Project|dropdown|on_change=on_filter|width=100%|>\n|sidebar>\n\n<main_page|\n# Employee Time Tracking System\n\n<|layout|columns=1 1 1|\n<total_entries|\n## Total Entries:\n### <|{len(df_selection)}|>\n|total_entries>\n\n<average_hours|\n## Average Hours Worked:\n### <|{round(df_selection[\"Hours\"].mean(), 2)}|> hours\n|average_hours>\n\n<time_tracking_table|\nDisplay df_selection in an expandable\n<|Time Tracking Table|expandable|expanded=False|\n<|{df_selection}|table|width=100%|page_size=10|rebuild|class_name=table|>\n|time_tracking_table>\n|main_page>\n|>\n\nCode adapted from [Employee Time Tracking](https://github.com/time_tracking_app)\n\nGet the Taipy Code [here](https://github.com/Avaiga/employee-time-tracking-app)\n"}
{"text": "# **Worldwide**{: .color-primary} Education Statistics\n\n<br/>\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Literacy Rate**{: .color-primary}\n<|{'{:.2f}%'.format(np.average(data_world_education['Literacy Rate']))}|text|class_name=h2|>\n|>\n\n<|card|\n**School Enrollment**{: .color-primary}\n<|{'{:.2f}%'.format(np.average(data_world_education['School Enrollment']))}|text|class_name=h2|>\n|>\n\n<|part|class_name=card|\n**Education Spending**{: .color-primary}\n<|{'{:.2f}%'.format(np.average(data_world_education['Education Spending']))}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|{selected_education_metric}|toggle|lov={education_metric_selector}|>\n\n<|part|render={selected_education_metric=='Absolute'}|\n<|layout|columns=1 2|\n<|{data_world_education_pie_absolute}|chart|type=pie|labels=Country|values=Literacy Rate|title=Global Literacy Rate Distribution|>\n\n<|{data_world_education_evolution_absolute}|chart|properties={data_world_education_evolution_properties}|title=Education Trends Worldwide|>\n|>\n|>\n\n<|part|render={selected_education_metric=='Relative'}|\n<|layout|columns=1 2|\n<|{data_world_education_pie_relative}|chart|type=pie|labels=Country|values=School Enrollment|>\n\n<|{data_world_education_evolution_relative}|chart|properties={data_world_education_evolution_relative_properties}|>\n|>\n|>\n"}
{"text": "<|layout|columns=2 9|gap=50px|\n<sidebar|sidebar|\n**Transportation Efficiency** Setup\n\n<|{selected_transport_scenario}|transport_scenario_selector|>\n|sidebar>\n\n<transport_scenario|part|render={selected_transport_scenario}|\n# **Public Transport Analysis**{: .color-primary} page\n\n<|1 1|layout|\n<date|\n#### Analysis **Date**{: .color-primary}\n\n<|{analysis_date}|date|on_change=on_change_transport_params|>\n|date>\n\n<route|\n#### **Route**{: .color-primary} for Analysis\n\n<|{selected_route}|selector|lov={selector_route}|dropdown|on_change=on_change_transport_params|label=Route|>\n|route>\n|>\n\n<|{selected_transport_scenario}|transport_scenario|on_submission_change=on_transport_scenario_submission_change|not expanded|>\n\n---------------------------------------\n\n## **Transport Efficiency Metrics**{: .color-primary} and Trends\n\n<|{selected_transport_scenario.result.read() if selected_transport_scenario and selected_transport_scenario.result.read() is not None else default_transport_result}|chart|x=Time|y[1]=Passenger Count|y[2]=Average Delay|type[1]=bar|title=Route Efficiency Analysis|>\n\n<|Data Nodes|expandable|\n<|1 5|layout|\n<|{selected_data_node}|data_node_selector|> \n\n<|{selected_data_node}|data_node|>\n|>\n|>\n\n|transport_scenario>\n|>\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\n\naudio_data = None\naudio_path = \"\"\n\ndef audio_upload(state):\n    if state.audio_path:\n        audio_data = state.audio_path  # Directly use the path for audio elements\n\naudio_page = \"\"\"\n<|{audio_path}|file_selector|accept=audio/*|on_action=audio_upload|>\n<|{audio_data}|audio|controls=True|>\n\"\"\"\n\nGui(audio_page).run()\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport io\n\ncsv_data = None\ncsv_path = \"\"\n\ndef csv_upload_analyze(state):\n    if state.csv_path:\n        state.csv_data = pd.read_csv(state.csv_path)\n        plt.figure()\n        state.csv_data.hist()\n        plt.xlabel(\"Values\")\n        plt.ylabel(\"Frequency\")\n        plt.title(\"Data Distribution\")\n        buf = io.BytesIO()\n        plt.savefig(buf, format='png')\n        buf.seek(0)\n        state.plot_image = buf.read()\n\ncsv_analyze_page = \"\"\"\n<|{csv_path}|file_selector|accept=.csv|on_action=csv_upload_analyze|>\n<|{csv_data}|table|>\n<|{plot_image}|image|>\n\"\"\"\n\nGui(csv_analyze_page).run()\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\n\n# Load project task data\ntask_data = pd.read_csv(\"project_task_data.csv\")\n\n# Initialize variables\nprojects = list(task_data[\"Project\"].unique())\npriorities = list(task_data[\"Priority\"].unique())\nproject = projects\npriority = priorities\n\n# Markdown for the entire page\npage = \"\"\"<|toggle|theme|>\n\n<|layout|columns=20 80|gap=30px|\n<sidebar|\n## **Filter**{: .orange} Project Tasks:\n\n<|{project}|selector|lov={projects}|multiple|label=Select Project|dropdown|on_change=on_filter|width=100%|>\n\n<|{priority}|selector|lov={priorities}|multiple|label=Select Priority|dropdown|on_change=on_filter|width=100%|>\n|sidebar>\n\n<main_page|\n# Project Task Management System\n\n<|layout|columns=1 1 1|\n<total_tasks|\n## Total Tasks:\n### <|{len(df_selection)}|>\n|total_tasks>\n\n<average_completion|\n## Average Completion Time:\n### <|{round(df_selection[\"Completion Time\"].mean(), 2)}|> days\n|average_completion>\n\n<task_management_table|\nDisplay df_selection in an expandable\n<|Task Management Table|expandable|expanded=False|\n<|{df_selection}|table|width=100%|page_size=10|rebuild|class_name=table|>\n|task_management_table>\n|main_page>\n|>\n\nCode adapted from [Project Task Management](https://github.com/task_management_app)\n\nGet the Taipy Code [here](https://github.com/Avaiga/project-task-management-app)\n"}
{"text": "from taipy.gui import Gui\nimport taipy as tp\n\n# Import pages for the homecare sector\nfrom pages.homecare.home import home_md\nfrom pages.homecare.services import services_md\nfrom pages.homecare.appointments import appointments_md\nfrom pages.homecare.contacts import contacts_md\n\n# Define your pages dictionary\npages = {\n    '/home': home_md,\n    '/services': services_md,\n    '/appointments': appointments_md,\n    '/contacts': contacts_md\n}\n\n# Create a Gui with your pages\ngui_homecare = Gui(pages=pages)\n\nif __name__ == '__main__':\n    tp.Core().run()\n    \n    # Run the multi-page app\n    gui_homecare.run(title=\"Homecare Dashboard\")\n"}
{"text": "# **Global**{: .color-primary} Technology Adoption\n\n<br/>\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Internet Users**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_world_tech['Internet Users']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n\n<|card|\n**Smartphone Penetration**{: .color-primary}\n<|{'{:.2f}%'.format(np.average(data_world_tech['Smartphone Penetration']))}|text|class_name=h2|>\n|>\n\n<|part|class_name=card|\n**AI Adoption**{: .color-primary}\n<|{'{:.2f}%'.format(np.average(data_world_tech['AI Adoption']))}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|{selected_tech_metric}|toggle|lov={tech_metric_selector}|>\n\n<|part|render={selected_tech_metric=='Absolute'}|\n<|layout|columns=1 2|\n<|{data_world_tech_pie_absolute}|chart|type=pie|labels=Country|values=Internet Users|title=Global Internet Usage|>\n\n<|{data_world_tech_evolution_absolute}|chart|properties={data_world_tech_evolution_properties}|title=Technology Evolution Worldwide|>\n|>\n|>\n\n<|part|render={selected_tech_metric=='Relative'}|\n<|layout|columns=1 2|\n<|{data_world_tech_pie_relative}|chart|type=pie|labels=Country|values=Smartphone Penetration|>\n\n<|{data_world_tech_evolution_relative}|chart|properties={data_world_tech_evolution_relative_properties}|>\n|>\n|>\n"}
{"text": "<|layout|columns=2 9|gap=50px|\n<sidebar|sidebar|\n**Supply Chain Analysis** Configuration\n\n<|{selected_supply_chain_scenario}|supply_chain_scenario_selector|>\n|sidebar>\n\n<supply_chain_scenario|part|render={selected_supply_chain_scenario}|\n# **Supply Chain Optimization**{: .color-primary} page\n\n<|1 1|layout|\n<date|\n#### Analysis **Start Date**{: .color-primary}\n\n<|{analysis_start_date}|date|on_change=on_change_supply_chain_params|>\n|date>\n\n<product|\n#### **Product**{: .color-primary} for Analysis\n\n<|{selected_product}|selector|lov={selector_product}|dropdown|on_change=on_change_supply_chain_params|label=Product|>\n|product>\n|>\n\n<|{selected_supply_chain_scenario}|supply_chain_scenario|on_submission_change=on_supply_chain_scenario_submission_change|not expanded|>\n\n---------------------------------------\n\n## **Supply Chain Dynamics**{: .color-primary} and Forecast\n\n<|{selected_supply_chain_scenario.result.read() if selected_supply_chain_scenario and selected_supply_chain_scenario.result.read() is not None else default_supply_chain_result}|chart|x=Date|y[1]=Demand|y[2]=Supply|type[1]=line|title=Supply vs. Demand Forecast|>\n\n<|Data Nodes|expandable|\n<|1 5|layout|\n<|{selected_data_node}|data_node_selector|> \n\n<|{selected_data_node}|data_node|>\n|>\n|>\n\n|supply_chain_scenario>\n|>\n"}
{"text": "# **Global**{: .color-primary} Tourism Statistics\n\n<br/>\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**International Tourist Arrivals**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_world_tourism['Tourist Arrivals']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n\n<|card|\n**Tourism Revenue**{: .color-primary}\n<|{'${:,.2f}'.format(np.sum(data_world_tourism['Revenue']))}|text|class_name=h2|>\n|>\n\n<|part|class_name=card|\n**Hotel Occupancy Rates**{: .color-primary}\n<|{'{:.2f}%'.format(np.average(data_world_tourism['Occupancy']))}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|{selected_tourism_metric}|toggle|lov={tourism_metric_selector}|>\n\n<|part|render={selected_tourism_metric=='Absolute'}|\n<|layout|columns=1 2|\n<|{data_world_tourism_pie_absolute}|chart|type=pie|labels=Country|values=Tourist Arrivals|title=Global Tourist Arrivals|>\n\n<|{data_world_tourism_evolution_absolute}|chart|properties={data_world_tourism_evolution_properties}|title=Tourism Trends Worldwide|>\n|>\n|>\n\n<|part|render={selected_tourism_metric=='Relative'}|\n<|layout|columns=1 2|\n<|{data_world_tourism_pie_relative}|chart|type=pie|labels=Country|values=Occupancy|>\n\n<|{data_world_tourism_evolution_relative}|chart|properties={data_world_tourism_evolution_relative_properties}|>\n|>\n|>\n"}
{"text": "# **Global**{: .color-primary} E-Commerce Trends\n\n<br/>\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Online Sales Volume**{: .color-primary}\n<|{'${:,.2f}'.format(np.sum(data_world_ecommerce['Sales Volume']))}|text|class_name=h2|>\n|>\n\n<|card|\n**Active Online Users**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_world_ecommerce['Active Users']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n\n<|part|class_name=card|\n**Average Purchase Value**{: .color-primary}\n<|{'${:,.2f}'.format(np.average(data_world_ecommerce['Purchase Value']))}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|{selected_ecommerce_metric}|toggle|lov={ecommerce_metric_selector}|>\n\n<|part|render={selected_ecommerce_metric=='Absolute'}|\n<|layout|columns=1 2|\n<|{data_world_ecommerce_pie_absolute}|chart|type=pie|labels=Country|values=Sales Volume|title=Global Online Sales Volume|>\n\n<|{data_world_ecommerce_evolution_absolute}|chart|properties={data_world_ecommerce_evolution_properties}|title=E-Commerce Trends Worldwide|>\n|>\n|>\n\n<|part|render={selected_ecommerce_metric=='Relative'}|\n<|layout|columns=1 2|\n<|{data_world_ecommerce_pie_relative}|chart|type=pie|labels=Country|values=Active Users|>\n\n<|{data_world_ecommerce_evolution_relative}|chart|properties={data_world_ecommerce_evolution_relative_properties}|>\n|>\n|>\n"}
{"text": "# **Global**{: .color-primary} Automotive Industry\n\n<br/>\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Total Vehicle Production**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_world_automotive['Vehicle Production']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n\n<|card|\n**Electric Vehicle Sales**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_world_automotive['EV Sales']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n\n<|part|class_name=card|\n**Market Share**{: .color-primary}\n<|{'{:.2f}%'.format(np.average(data_world_automotive['Market Share']))}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|{selected_automotive_metric}|toggle|lov={automotive_metric_selector}|>\n\n<|part|render={selected_automotive_metric=='Absolute'}|\n<|layout|columns=1 2|\n<|{data_world_automotive_pie_absolute}|chart|type=pie|labels=Country|values=Vehicle Production|title=Global Vehicle Production|>\n\n<|{data_world_automotive_evolution_absolute}|chart|properties={data_world_automotive_evolution_properties}|title=Automotive Industry Trends|>\n|>\n|>\n\n<|part|render={selected_automotive_metric=='Relative'}|\n<|layout|columns=1 2|\n<|{data_world_automotive_pie_relative}|chart|type=pie|labels=Country|values=EV Sales|>\n\n<|{data_world_automotive_evolution_relative}|chart|properties={data_world_automotive_evolution_relative_properties}|>\n|>\n|>\n"}
{"text": "from taipy import Gui\n\nimport numpy as np\nfrom PIL import Image\nimport matplotlib.pyplot as plt\n\nWINDOW_SIZE = 500\n\ncm = plt.cm.get_cmap(\"viridis\")\n\n\ndef generate_mandelbrot(\n    center: int = WINDOW_SIZE / 2,\n    dx_range: int = 1000,\n    dx_start: float = -0.12,\n    dy_range: float = 1000,\n    dy_start: float = -0.82,\n    iterations: int = 50,\n    max_value: int = 200,\n    i: int = 0,\n) -> str:\n    mat = np.zeros((WINDOW_SIZE, WINDOW_SIZE))\n    for y in range(WINDOW_SIZE):\n        for x in range(WINDOW_SIZE):\n            dx = (x - center) / dx_range + dx_start\n            dy = (y - center) / dy_range + dy_start\n            a = dx\n            b = dy\n            for t in range(iterations):\n                d = (a * a) - (b * b) + dx\n                b = 2 * (a * b) + dy\n                a = d\n                h = d > max_value\n                if h is True:\n                    mat[x, y] = t\n\n    colored_mat = cm(mat / mat.max())\n    im = Image.fromarray((colored_mat * 255).astype(np.uint8))\n    path = f\"mandelbrot_{i}.png\"\n    im.save(path)\n\n    return path\n\n\ndef generate(state):\n    state.i = state.i + 1\n    state.path = generate_mandelbrot(\n        dx_start=-state.dx_start / 100,\n        dy_start=(state.dy_start - 100) / 100,\n        iterations=state.iterations,\n        i=state.i,\n    )\n\n\ni = 0\ndx_start = 11\ndy_start = 17\niterations = 50\n\npath = generate_mandelbrot(\n    dx_start=-dx_start / 100,\n    dy_start=(dy_start - 100) / 100,\n)\n\npage = \"\"\"\n# Mandelbrot Generator\n\n<|layout|columns=35 65|\nDisplay image from path\n<|{path}|image|width=500px|height=500px|class_name=img|>\n\nIterations:<br />\nCreate a slider to select iterations\n<|{iterations}|slider|min=10|max=50|continuous=False|on_change=generate|><br />\nX Position:<br />\n<|{dy_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />\nY Position:<br />\n\nSlider dx_start\n<|{dx_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />\n|>\n\"\"\"\n\nGui(page).run(title=\"Mandelbrot Generator\")\n"}
{"text": "<|{all_appointments}|table|columns={appointment_columns}|width='100%'|on_action={on_appointment_select}|style=appointment_style|>\n<|Book Appointment|button|on_action={open_book_appointment_dialog}|>\n<|Refresh Appointments|button|on_action={refresh_appointment_list}|>\n\n<|{show_book_appointment_dialog}|dialog|title=Book New Appointment|\n<|{patient_name}|input|placeholder='Patient Name'|\n<|{appointment_date}|datetime_picker|>\n<|{doctor_selector}|selector|lov={get_all_doctors()}|>\n<|Book|button|on_action={book_appointment}|>\n<|Cancel|button|on_action={close_book_appointment_dialog}|>\n|>\n\n<|{show_appointment_details}|pane|\n\n# Appointment Details <|Edit|button|on_action=edit_selected_appointment|> <|Cancel|button|on_action=cancel_selected_appointment|>\n\n<|layout|columns=1|\n<|part|class_name=card|\n## Patient Name\n<|{selected_appointment.patient_name}|>\n|>\n\n<|part|class_name=card|\n## Date and Time\n<|{selected_appointment.date.strftime(\"%b %d, %Y at %H:%M\")}|>\n|>\n\n<|part|class_name=card|\n## Doctor\n<|{selected_appointment.doctor}|>\n|>\n\n<|part|class_name=card|\n## Status\n<|{get_appointment_status(selected_appointment)}|>\n|>\n\n----\n|>\n"}
{"text": "# **Global**{: .color-primary} Food Security and Agriculture\n\n<br/>\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Cereal Production**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_world_agri['Cereal Production']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n\n<|card|\n**Agricultural Land**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_world_agri['Agricultural Land']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n\n<|part|class_name=card|\n**Undernourishment Rate**{: .color-primary}\n<|{'{:.2f}%'.format(np.average(data_world_agri['Undernourishment Rate']))}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|{selected_agri_metric}|toggle|lov={agri_metric_selector}|>\n\n<|part|render={selected_agri_metric=='Absolute'}|\n<|layout|columns=1 2|\n<|{data_world_agri_pie_absolute}|chart|type=pie|labels=Country|values=Cereal Production|title=Global Cereal Production|>\n\n<|{data_world_agri_evolution_absolute}|chart|properties={data_world_agri_evolution_properties}|title=Agricultural Trends Worldwide|>\n|>\n|>\n\n<|part|render={selected_agri_metric=='Relative'}|\n<|layout|columns=1 2|\n<|{data_world_agri_pie_relative}|chart|type=pie|labels=Country|values=Undernourishment Rate|>\n\n<|{data_world_agri_evolution_relative}|chart|properties={data_world_agri_evolution_relative_properties}|>\n|>\n|>\n"}
{"text": "if __name__ == \"__main__\":\n    # Initialize with custom sector-related values\n    topic = \"E-commerce\"\n    mood = \"shopping\"\n    style = \"ecommerceexpert\"\n\n    # Create a GUI page with custom settings\n    page = \"\"\"\n    <|container|\n    # **Generate**{: .color-primary} E-commerce Tweets\n\n    This mini-app generates Tweets related to E-commerce 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    <br/>\n\n    <|layout|columns=1 1 1|gap=30px|class_name=card|\n    <topic|\n    ## **Topic**{: .color-primary} (or hashtag)\n\n    <|{topic}|input|label=E-commerce Topic (or hashtag)|>\n    |topic>\n\n    <mood|\n    ## **Mood**{: .color-primary}\n\n    <|{mood}|input|label=Mood (e.g. shopping, deals, online retail) (optional)|>\n    |mood>\n\n    <style|\n    ## Twitter **account**{: .color-primary}\n\n    <|{style}|input|label=Twitter account handle to style-copy recent E-commerce Tweets (optional)|>\n    |style>\n\n    Create a Generate text button\n    <|Generate E-commerce Tweet|button|on_action=generate_text|label=Generate text|>\n\n    <image|part|render={prompt != \"\" and tweet != \"\" and image is not None}|class_name=card|\n    ### **Image**{: .color-primary} for E-commerce\n\n    Display image\n    <center><|{image}|image|height=400px|></center>\n    |image>\n\n    Break line\n    <br/>\n\n    **Code from [@kinosal](https://twitter.com/kinosal)**\n\n    Original code can be found [here](https://github.com/kinosal/tweet)\n    |>\n    \"\"\"\n\n    Gui(page).run(dark_mode=False, port=5089)\n"}
{"text": "from taipy.gui import Gui\nimport taipy as tp\n\n# Import pages related to education and healthcare (replace with actual imports)\nfrom pages.education.education import education_md\nfrom pages.healthcare.healthcare import healthcare_md\n\n# Define the pages\npages = {\n    '/': root,  # Replace with the root page if you have one\n    \"Education\": education_md,\n    \"Healthcare\": healthcare_md,\n}\n\n# Create a Gui instance with the pages\ngui_multi_pages = Gui(pages=pages)\n\nif __name__ == '__main__':\n    tp.Core().run()\n\n    # Run the multi-page app\n    gui_multi_pages.run(title=\"Education & Healthcare Dashboard\")\n"}
{"text": "<|{all_properties}|table|columns={property_columns}|width='100%'|on_action={on_property_select}|style=property_style|>\n<|Add Property|button|on_action={open_add_property_dialog}|>\n<|Refresh Properties|button|on_action={refresh_property_list}|>\n\n<|{show_add_property_dialog}|dialog|title=Add New Property|\n<|{property_address}|input|placeholder='Address'|\n<|{property_price}|number_input|placeholder='Price'|\n<|Add Property|button|on_action={add_property}|>\n<|Cancel|button|on_action={close_add_property_dialog}|>\n|>\n\n<|{show_property_details}|pane|\n\n# Property Details <|Edit|button|on_action=edit_selected_property|> <|Remove|button|on_action=remove_selected_property|>\n\n<|layout|columns=2|\n<|part|class_name=card|\n## Address\n<|{selected_property.address}|>\n|>\n\n<|part|class_name=card|\n## Price\n<|{selected_property.price}|>\n|>\n\n<|part|class_name=card|\n## Listed Date\n<|{selected_property.listed_date.strftime(\"%b %d, %Y\")}|>\n|>\n\n----\n|>\n"}
{"text": "from taipy.gui import Gui\nimport taipy as tp\n\n# Import pages for the education sector\nfrom pages.education.home import home_md\nfrom pages.education.courses import courses_md\nfrom pages.education.students import students_md\nfrom pages.education.teachers import teachers_md\n\n# Define your pages dictionary\npages = {\n    '/home': home_md,\n    '/courses': courses_md,\n    '/students': students_md,\n    '/teachers': teachers_md\n}\n\n# Create a Gui with your pages\ngui_education = Gui(pages=pages)\n\nif __name__ == '__main__':\n    tp.Core().run()\n    \n    # Run the multi-page app\n    gui_education.run(title=\"Education Dashboard\")\n"}
{"text": "# **Country**{: .color-primary} Education Statistics\n\n<|layout|columns=1 1 1|\n<|{selected_country_education}|selector|lov={selector_country_education}|on_change=on_change_country_education|dropdown|label=Country|>\n\n<|{selected_education_level}|toggle|lov={education_level_selector}|on_change=update_education_level_display|>\n|>\n\n<br/>\n\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Literacy Rate**{: .color-primary}\n<|{'{:.2f}%'.format(education_data.iloc[-1]['Literacy Rate'])}|text|class_name=h2|>\n|>\n\n<|card|\n**School Enrollment**{: .color-primary}\n<|{'{:.2f}%'.format(education_data.iloc[-1]['School Enrollment'])}|text|class_name=h2|>\n|>\n\n<|card|\n**Average Education Years**{: .color-primary}\n<|{'{:.1f}'.format(education_data.iloc[-1]['Average Education Years'])}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|layout|columns=2 1|\n<|{education_data}|chart|type=bar|x=Year|y[3]=Literacy Rate|y[2]=School Enrollment|y[1]=Average Education Years|layout={layout}|options={options}|title=Education Progress|>\n\n<|{education_level_chart}|chart|type=pie|values=education_level_values|labels=education_level_labels|title=Education Level Distribution|>\n|>\n"}
{"text": "# **Worldwide**{: .color-primary} Renewable Energy Usage\n\n<br/>\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Solar Energy Production**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_world_energy['Solar Energy']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n\n<|card|\n**Wind Energy Production**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_world_energy['Wind Energy']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n\n<|part|class_name=card|\n**Hydropower Energy Production**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_world_energy['Hydropower']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|{selected_energy_metric}|toggle|lov={energy_metric_selector}|>\n\n<|part|render={selected_energy_metric=='Absolute'}|\n<|layout|columns=1 2|\n<|{data_world_energy_pie_absolute}|chart|type=pie|labels=Country|values=Solar Energy|title=Global Solar Energy Production|>\n\n<|{data_world_energy_evolution_absolute}|chart|properties={data_world_energy_evolution_properties}|title=Renewable Energy Trends Worldwide|>\n|>\n|>\n\n<|part|render={selected_energy_metric=='Relative'}|\n<|layout|columns=1 2|\n<|{data_world_energy_pie_relative}|chart|type=pie|labels=Country|values=Wind Energy|>\n\n<|{data_world_energy_evolution_relative}|chart|properties={data_world_energy_evolution_relative_properties}|>\n|>\n|>\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\n\nexcel_data = []\nexcel_path = \"\"\n\ndef excel_upload(state):\n    state.excel_data = pd.read_excel(state.excel_path)\n\nexcel_page = \"\"\"\n<|{excel_path}|file_selector|accept=.xlsx|on_action=excel_upload|>\n<|{excel_data}|table|>\n\"\"\"\n\nGui(excel_page).run()\n"}
{"text": "from taipy.gui import Gui\nimport taipy as tp\n\n# Import pages for the retail sector\nfrom pages.retail.home import home_md\nfrom pages.retail.products import products_md\nfrom pages.retail.customers import customers_md\nfrom pages.retail.sales import sales_md\n\n# Define your pages dictionary\npages = {\n    '/home': home_md,\n    '/products': products_md,\n    '/customers': customers_md,\n    '/sales': sales_md\n}\n\n# Create a Gui with your pages\ngui_retail = Gui(pages=pages)\n\nif __name__ == '__main__':\n    tp.Core().run()\n    \n    # Run the multi-page app\n    gui_retail.run(title=\"Retail Dashboard\")\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\n\n# Load customer feedback data\nfeedback_data = pd.read_csv(\"customer_feedback_data.csv\")\n\n# Initialize variables\nproducts = list(feedback_data[\"Product\"].unique())\nsentiments = list(feedback_data[\"Sentiment\"].unique())\nproduct = products\nsentiment = sentiments\n\n# Markdown for the entire page\npage = \"\"\"<|toggle|theme|>\n\n<|layout|columns=20 80|gap=30px|\n<sidebar|\n## **Filter**{: .orange} Customer Feedback Analysis:\n\n<|{product}|selector|lov={products}|multiple|label=Select Product|dropdown|on_change=on_filter|width=100%|>\n\n<|{sentiment}|selector|lov={sentiments}|multiple|label=Select Sentiment|dropdown|on_change=on_filter|width=100%|>\n|sidebar>\n\n<main_page|\n# Customer Feedback Analysis\n\n<|layout|columns=1 1 1|\n<total_feedback|\n## Total Feedback:\n### <|{len(df_selection)}|>\n|total_feedback>\n\n<average_rating|\n## Average Rating:\n### <|{round(df_selection[\"Rating\"].mean(), 2)}|> out of 5\n|average_rating>\n\n<feedback_table|\nDisplay df_selection in an expandable\n<|Feedback Table|expandable|expanded=False|\n<|{df_selection}|table|width=100%|page_size=10|rebuild|class_name=table|>\n|feedback_table>\n|main_page>\n|>\n\nCode adapted from [Customer Feedback Analysis](https://github.com/feedback_analysis_app)\n\nGet the Taipy Code [here](https://github.com/Avaiga/customer-feedback-analysis-app)\n"}
{"text": "<|layout|columns=2 9|gap=50px|\n<sidebar|sidebar|\n**Forecast** Creation\n\n<|{selected_forecast}|forecast_selector|>\n|sidebar>\n\n<forecast|part|render={selected_forecast}|\n# **Financial Forecast**{: .color-primary} page\n\n<|1 1|layout|\n<date|\n#### Start **Date**{: .color-primary} of Forecast\n\n<|{forecast_start_date}|date|on_change=on_change_forecast_params|>\n|date>\n\n<market|\n#### **Market**{: .color-primary} for Forecast\n\n<|{selected_market}|selector|lov={selector_market}|dropdown|on_change=on_change_forecast_params|label=Market|>\n|market>\n|>\n\n<|{selected_forecast}|forecast|on_submission_change=on_submission_change_forecast|not expanded|>\n\n---------------------------------------\n\n## **Market Predictions**{: .color-primary} and Data Explorer\n\n<|{selected_forecast.result.read() if selected_forecast and selected_forecast.result.read() is not None else default_market_result}|chart|x=Date|y[1]=Market Value|y[2]=Trend Prediction|type[1]=line|title=Market Forecast|>\n\n<|Data Nodes|expandable|\n<|1 5|layout|\n<|{selected_data_node}|data_node_selector|> \n\n<|{selected_data_node}|data_node|>\n|>\n|>\n\n|forecast>\n|>\n"}
{"text": "<|{all_classes}|table|columns={class_columns}|width='100%'|on_action={on_class_select}|style=class_style|>\n<|Schedule Class|button|on_action={open_schedule_class_dialog}|>\n<|Refresh Classes|button|on_action={refresh_class_list}|>\n\n<|{show_schedule_class_dialog}|dialog|title=Schedule New Class|\n<|{class_subject}|input|placeholder='Class Subject'|\n<|{class_date}|date_picker|>\n<|Schedule|button|on_action={schedule_class}|>\n<|Cancel|button|on_action={close_schedule_class_dialog}|>\n|>\n\n<|{show_class_details}|pane|\n\n# Class Details <|Edit|button|on_action=edit_selected_class|> <|Cancel|button|on_action=cancel_selected_class|>\n\n<|layout|columns=1|\n<|part|class_name=card|\n## Subject\n<|{selected_class.subject}|>\n|>\n\n<|part|class_name=card|\n## Date\n<|{selected_class.date.strftime(\"%b %d, %Y at %H:%M\")}|>\n|>\n\n<|part|class_name=card|\n## Instructor\n<|{selected_class.instructor}|>\n|>\n\n<|part|class_name=card|\n## Enrollment\n<|{selected_class.enrollment}|number_input|disabled=True|>\n|>\n\n----\n|>\n"}
{"text": "if __name__ == \"__main__\":\n    # Initialize with custom sector-related values\n    topic = \"Healthcare\"\n    mood = \"medical\"\n    style = \"healthexpert\"\n\n    # Create a GUI page with custom settings\n    page = \"\"\"\n    <|container|\n    # **Generate**{: .color-primary} Healthcare Tweets\n\n    This mini-app generates Tweets related to Healthcare 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    <br/>\n\n    <|layout|columns=1 1 1|gap=30px|class_name=card|\n    <topic|\n    ## **Topic**{: .color-primary} (or hashtag)\n\n    <|{topic}|input|label=Healthcare Topic (or hashtag)|>\n    |topic>\n\n    <mood|\n    ## **Mood**{: .color-primary}\n\n    <|{mood}|input|label=Mood (e.g. medical, informative, healthcare) (optional)|>\n    |mood>\n\n    <style|\n    ## Twitter **account**{: .color-primary}\n\n    <|{style}|input|label=Twitter account handle to style-copy recent Healthcare Tweets (optional)|>\n    |style>\n\n    Create a Generate text button\n    <|Generate Healthcare Tweet|button|on_action=generate_text|label=Generate text|>\n\n    <image|part|render={prompt != \"\" and tweet != \"\" and image is not None}|class_name=card|\n    ### **Image**{: .color-primary} for Healthcare\n\n    Display image\n    <center><|{image}|image|height=400px|></center>\n    |image>\n\n    Break line\n    <br/>\n\n    **Code from [@kinosal](https://twitter.com/kinosal)**\n\n    Original code can be found [here](https://github.com/kinosal/tweet)\n    |>\n    \"\"\"\n\n    Gui(page).run(dark_mode=False, port=5089)\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\n\nvideo_data = None\nvideo_path = \"\"\n\ndef video_upload(state):\n    if state.video_path:\n        video_data = state.video_path  # Directly use the path for video elements\n\nvideo_page = \"\"\"\n<|{video_path}|file_selector|accept=video/*|on_action=video_upload|>\n<|{video_data}|video|controls=True|>\n\"\"\"\n\nGui(video_page).run()\n"}
{"text": "<|layout|columns=2 9|gap=50px|\n<sidebar|sidebar|\n**Impact Monitoring** Configuration\n\n<|{selected_environmental_scenario}|environmental_scenario_selector|>\n|sidebar>\n\n<environmental_scenario|part|render={selected_environmental_scenario}|\n# **Environmental Impact Assessment**{: .color-primary} page\n\n<|1 1|layout|\n<date|\n#### Monitoring **Date**{: .color-primary}\n\n<|{monitoring_date}|date|on_change=on_change_environmental_params|>\n|date>\n\n<region|\n#### **Region**{: .color-primary} for Monitoring\n\n<|{selected_region}|selector|lov={selector_region}|dropdown|on_change=on_change_environmental_params|label=Region|>\n|region>\n|>\n\n<|{selected_environmental_scenario}|environmental_scenario|on_submission_change=on_environmental_scenario_submission_change|not expanded|>\n\n---------------------------------------\n\n## **Environmental Metrics**{: .color-primary} and Trends\n\n<|{selected_environmental_scenario.result.read() if selected_environmental_scenario and selected_environmental_scenario.result.read() is not None else default_environmental_result}|chart|x=Date|y[1]=Air Quality Index|y[2]=Water Purity Level|type[1]=line|title=Environmental Conditions|>\n\n<|Data Nodes|expandable|\n<|1 5|layout|\n<|{selected_data_node}|data_node_selector|> \n\n<|{selected_data_node}|data_node|>\n|>\n|>\n\n|environmental_scenario>\n|>\n"}
{"text": "if __name__ == \"__main__\":\n    # Initialize with custom sector-related values\n    topic = \"Healthcare\"\n    mood = \"healthtech\"\n    style = \"healthcarepro\"\n\n    # Create a GUI page with custom settings\n    page = \"\"\"\n    <|container|\n    # **Generate**{: .color-primary} Healthcare Tweets\n\n    This mini-app generates Tweets related to Healthcare 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    <br/>\n\n    <|layout|columns=1 1 1|gap=30px|class_name=card|\n    <topic|\n    ## **Topic**{: .color-primary} (or hashtag)\n\n    <|{topic}|input|label=Healthcare Topic (or hashtag)|>\n    |topic>\n\n    <mood|\n    ## **Mood**{: .color-primary}\n\n    <|{mood}|input|label=Mood (e.g. healthtech, medicalresearch, healthcareinnovation) (optional)|>\n    |mood>\n\n    <style|\n    ## Twitter **account**{: .color-primary}\n\n    <|{style}|input|label=Twitter account handle to style-copy recent Healthcare Tweets (optional)|>\n    |style>\n\n    Create a Generate text button\n    <|Generate Healthcare Tweet|button|on_action=generate_text|label=Generate text|>\n\n    <image|part|render={prompt != \"\" and tweet != \"\" and image is not None}|class_name=card|\n    ### **Image**{: .color-primary} for Healthcare\n\n    Display image\n    <center><|{image}|image|height=400px|></center>\n    |image>\n\n    Break line\n    <br/>\n\n    **Code from [@kinosal](https://twitter.com/kinosal)**\n\n    Original code can be found [here](https://github.com/kinosal/tweet)\n    |>\n    \"\"\"\n\n    Gui(page).run(dark_mode=False, port=5089)\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport io\n\ncsv_data = pd.DataFrame()\ncsv_path = \"\"\n\ndef csv_upload_plot(state):\n    if state.csv_path:\n        state.csv_data = pd.read_csv(state.csv_path)\n        plt.figure()\n        state.csv_data.plot(kind='line')\n        buf = io.BytesIO()\n        plt.savefig(buf, format='png')\n        buf.seek(0)\n        state.plot_image = buf.read()\n\ncsv_plot_page = \"\"\"\n<|{csv_path}|file_selector|accept=.csv|on_action=csv_upload_plot|>\n<|{plot_image}|image|>\n\"\"\"\n\nGui(csv_plot_page).run()\n"}
{"text": "<|layout|columns=2 9|gap=50px|\n<sidebar|sidebar|\n**Weather Forecast** Setup\n\n<|{selected_weather_forecast}|weather_forecast_selector|>\n|sidebar>\n\n<weather_forecast|part|render={selected_weather_forecast}|\n# **Weather Prediction**{: .color-primary} page\n\n<|1 1|layout|\n<date|\n#### Forecast **Date**{: .color-primary}\n\n<|{forecast_date}|date|on_change=on_change_weather_params|>\n|date>\n\n<location|\n#### **Location**{: .color-primary} for Forecast\n\n<|{selected_location}|selector|lov={selector_location}|dropdown|on_change=on_change_weather_params|label=Location|>\n|location>\n|>\n\n<|{selected_weather_forecast}|weather_forecast|on_submission_change=on_submission_change_weather|not expanded|>\n\n---------------------------------------\n\n## **Weather Predictions**{: .color-primary} and Data Analysis\n\n<|{selected_weather_forecast.result.read() if selected_weather_forecast and selected_weather_forecast.result.read() is not None else default_weather_result}|chart|x=Date|y[1]=Temperature|y[2]=Humidity|y[3]=Precipitation|type[1]=line|title=Weather Forecast|>\n\n<|Data Nodes|expandable|\n<|1 5|layout|\n<|{selected_data_node}|data_node_selector|> \n\n<|{selected_data_node}|data_node|>\n|>\n|>\n\n|weather_forecast>\n|>\n"}
{"text": "<|{all_books}|table|columns={book_columns}|width='100%'|on_action={on_book_select}|style=book_style|>\n<|Add Book|button|on_action={open_add_book_dialog}|>\n<|Refresh Books|button|on_action={refresh_book_list}|>\n\n<|{show_add_book_dialog}|dialog|title=Add New Book|\n<|{book_title}|input|placeholder='Title'|\n<|{book_author}|input|placeholder='Author'|\n<|{book_genre}|selector|lov={get_all_genres()}|>\n<|Add Book|button|on_action={add_book}|>\n<|Cancel|button|on_action={close_add_book_dialog}|>\n|>\n\n<|{show_book_details}|pane|\n\n# Book Details <|Edit|button|on_action=edit_selected_book|> <|Remove|button|on_action=remove_selected_book|>\n\n<|layout|columns=1|\n<|part|class_name=card|\n## Title\n<|{selected_book.title}|>\n|>\n\n<|part|class_name=card|\n## Author\n<|{selected_book.author}|>\n|>\n\n<|part|class_name=card|\n## Genre\n<|{selected_book.genre}|>\n|>\n\n<|part|class_name=card|\n## ISBN\n<|{selected_book.isbn}|>\n|>\n\n----\n|>\n"}
{"text": "if __name__ == \"__main__\":\n    # Initialize with custom sector-related values\n    topic = \"Transportation\"\n    mood = \"travel\"\n    style = \"transitexpert\"\n\n    # Create a GUI page with custom settings\n    page = \"\"\"\n    <|container|\n    # **Generate**{: .color-primary} Transportation Tweets\n\n    This mini-app generates Tweets related to Transportation 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    <br/>\n\n    <|layout|columns=1 1 1|gap=30px|class_name=card|\n    <topic|\n    ## **Topic**{: .color-primary} (or hashtag)\n\n    <|{topic}|input|label=Transportation Topic (or hashtag)|>\n    |topic>\n\n    <mood|\n    ## **Mood**{: .color-primary}\n\n    <|{mood}|input|label=Mood (e.g. travel, transit, journeys) (optional)|>\n    |mood>\n\n    <style|\n    ## Twitter **account**{: .color-primary}\n\n    <|{style}|input|label=Twitter account handle to style-copy recent Transportation Tweets (optional)|>\n    |style>\n\n    Create a Generate text button\n    <|Generate Transportation Tweet|button|on_action=generate_text|label=Generate text|>\n\n    <image|part|render={prompt != \"\" and tweet != \"\" and image is not None}|class_name=card|\n    ### **Image**{: .color-primary} for Transportation\n\n    Display image\n    <center><|{image}|image|height=400px|></center>\n    |image>\n\n    Break line\n    <br/>\n\n    **Code from [@kinosal](https://twitter.com/kinosal)**\n\n    Original code can be found [here](https://github.com/kinosal/tweet)\n    |>\n    \"\"\"\n\n    Gui(page).run(dark_mode=False, port=5089)\n"}
{"text": "# **Worldwide**{: .color-primary} Energy Consumption\n\n<br/>\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Total Energy Consumption**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_world_energy_consumption['Total Energy']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n\n<|card|\n**Renewable Energy Consumption**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_world_energy_consumption['Renewable Energy']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n\n<|part|class_name=card|\n**Fossil Fuel Consumption**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_world_energy_consumption['Fossil Fuels']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|{selected_energy_consumption_metric}|toggle|lov={energy_consumption_metric_selector}|>\n\n<|part|render={selected_energy_consumption_metric=='Absolute'}|\n<|layout|columns=1 2|\n<|{data_world_energy_consumption_pie_absolute}|chart|type=pie|labels=Country|values=Total Energy|title=Global Energy Consumption|>\n\n<|{data_world_energy_consumption_evolution_absolute}|chart|properties={data_world_energy_consumption_evolution_properties}|title=Energy Consumption Trends Worldwide|>\n|>\n|>\n\n<|part|render={selected_energy_consumption_metric=='Relative'}|\n<|layout|columns=1 2|\n<|{data_world_energy_consumption_pie_relative}|chart|type=pie|labels=Country|values=Renewable Energy|>\n\n<|{data_world_energy_consumption_evolution_relative}|chart|properties={data_world_energy_consumption_evolution_relative_properties}|>\n|>\n|>\n"}
{"text": "from taipy import Gui\nimport numpy as np\nfrom PIL import Image\nimport matplotlib.pyplot as plt\n\nWINDOW_SIZE = 500\n\ncm = plt.cm.get_cmap(\"viridis\")\n\n\ndef generate_mandelbrot(\n    center: int = WINDOW_SIZE / 2,\n    dx_range: int = 1000,\n    dx_start: float = -0.12,\n    dy_range: float = 1000,\n    dy_start: float = -0.82,\n    iterations: int = 50,\n    max_value: int = 200,\n    i: int = 0,\n) -> str:\n    mat = np.zeros((WINDOW_SIZE, WINDOW_SIZE))\n    for y in range(WINDOW_SIZE):\n        for x in range(WINDOW_SIZE):\n            dx = (x - center) / dx_range + dx_start\n            dy = (y - center) / dy_range + dy_start\n            a = dx\n            b = dy\n            for t in range(iterations):\n                d = (a * a) - (b * b) + dx\n                b = 2 * (a * b) + dy\n                a = d\n                h = d > max_value\n                if h is True:\n                    mat[x, y] = t\n\n    colored_mat = cm(mat / mat.max())\n    im = Image.fromarray((colored_mat * 255).astype(np.uint8))\n    path = f\"mandelbrot_{i}.png\"\n    im.save(path)\n\n    return path\n\n\ndef generate(state):\n    state.i = state.i + 1\n    state.path = generate_mandelbrot(\n        dx_start=-state.dx_start / 100,\n        dy_start=(state.dy_start - 100) / 100,\n        iterations=state.iterations,\n        i=state.i,\n    )\n\n\ni =\n"}
{"text": "from taipy import Gui\nimport numpy as np\nfrom PIL import Image\nimport matplotlib.pyplot as plt\n\nWINDOW_SIZE = 500\n\ncm = plt.cm.get_cmap(\"viridis\")\n\n\ndef generate_mandelbrot(\n    center: int = WINDOW_SIZE / 2,\n    dx_range: int = 1000,\n    dx_start: float = -0.12,\n    dy_range: float = 1000,\n    dy_start: float = -0.82,\n    iterations: int = 50,\n    max_value: int = 200,\n    i: int = 0,\n) -> str:\n    mat = np.zeros((WINDOW_SIZE, WINDOW_SIZE))\n    for y in range(WINDOW_SIZE):\n        for x in range(WINDOW_SIZE):\n            dx = (x - center) / dx_range + dx_start\n            dy = (y - center) / dy_range + dy_start\n            a = dx\n            b = dy\n            for t in range(iterations):\n                d = (a * a) - (b * b) + dx\n                b = 2 * (a * b) + dy\n                a = d\n                h = d > max_value\n                if h is True:\n                    mat[x, y] = t\n\n    colored_mat = cm(mat / mat.max())\n    im = Image.fromarray((colored_mat * 255).astype(np.uint8))\n    path = f\"mandelbrot_{i}.png\"\n    im.save(path)\n\n    return path\n\n\ndef generate(state):\n    state.i = state.i + 1\n    state.path = generate_mandelbrot(\n        dx_start=-state.dx_start / 100,\n        dy_start=(state.dy_start - 100) / 100,\n        iterations=state.iterations,\n        i=state.i,\n    )\n\n\ni = 0\ndx_start = 11\ndy_start = 17\niterations = 50\n\npath = generate_mandelbrot(\n    dx_start=-dx_start / 100,\n    dy_start=(dy_start - 100) / 100,\n)\n\npage = \"\"\"\n# Mandelbrot Fractal for Automotive Visualization\n\n<|layout|columns=35 65|\nVisualize Complex Patterns with Mandelbrot Fractals\n<|{path}|image|width=500px|height=500px|class_name=img|>\n\nIterations:<br />\nSelect the number of iterations to explore fractal patterns\n<|{iterations}|slider|min=10|max=50|continuous=False|on_change=generate|><br />\nX Position:<br />\n<|{dy_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />\nY Position:<br />\n\nSlider dx_start\n<|{dx_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />\n|>\n\"\"\"\n\nGui(page).run(title=\"Mandelbrot Fractal for Automotive Visualization\")\n"}
{"text": "<|{all_fitness_classes}|table|columns={fitness_class_columns}|width='100%'|on_action={on_fitness_class_select}|style=fitness_class_style|>\n<|Schedule Fitness Class|button|on_action={open_schedule_fitness_class_dialog}|>\n<|Refresh Classes|button|on_action={refresh_fitness_classes}|>\n\n<|{show_schedule_fitness_class_dialog}|dialog|title=Schedule Fitness Class|\n<|{class_type}|selector|lov={get_all_class_types()}|>\n<|{class_instructor}|input|placeholder='Instructor Name'|\n<|{class_time}|time_picker|>\n<|Schedule Class|button|on_action={schedule_fitness_class}|>\n<|Cancel|button|on_action={close_schedule_fitness_class_dialog}|>\n|>\n\n<|{show_fitness_class_details}|pane|\n\n# Class Details <|Edit|button|on_action=edit_selected_class|> <|Cancel|button|on_action=cancel_selected_class|>\n\n<|layout|columns=1|\n<|part|class_name=card|\n## Class Type\n<|{selected_fitness_class.type}|>\n|>\n\n<|part|class_name=card|\n## Instructor\n<|{selected_fitness_class.instructor}|>\n|>\n\n<|part|class_name=card|\n## Time\n<|{selected_fitness_class.time.strftime(\"%H:%M\")}|>\n|>\n\n----\n|>\n"}
{"text": "# **Global**{: .color-primary} Digital Connectivity\n\n<br/>\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Internet Connectivity Rate**{: .color-primary}\n<|{'{:.2f}%'.format(np.average(data_world_digital['Connectivity Rate']))}|text|class_name=h2|>\n|>\n\n<|card|\n**Smart Device Usage**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_world_digital['Smart Devices']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n\n<|part|class_name=card|\n**Broadband Subscriptions**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_world_digital['Broadband Subscriptions']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|{selected_digital_metric}|toggle|lov={digital_metric_selector}|>\n\n<|part|render={selected_digital_metric=='Absolute'}|\n<|layout|columns=1 2|\n<|{data_world_digital_pie_absolute}|chart|type=pie|labels=Country|values=Connectivity Rate|title=Global Internet Connectivity|>\n\n<|{data_world_digital_evolution_absolute}|chart|properties={data_world_digital_evolution_properties}|title=Digital Connectivity Trends|>\n|>\n|>\n\n<|part|render={selected_digital_metric=='Relative'}|\n<|layout|columns=1 2|\n<|{data_world_digital_pie_relative}|chart|type=pie|labels=Country|values=Smart Devices|>\n\n<|{data_world_digital_evolution_relative}|chart|properties={data_world_digital_evolution_relative_properties}|>\n|>\n|>\n"}
{"text": "if __name__ == \"__main__\":\n    # Initialize with custom sector-related values\n    topic = \"Automotive\"\n    mood = \"automotivenews\"\n    style = \"automotivepro\"\n\n    # Create a GUI page with custom settings\n    page = \"\"\"\n    <|container|\n    # **Generate**{: .color-primary} Automotive Tweets\n\n    This mini-app generates Tweets related to Automotive 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    <br/>\n\n    <|layout|columns=1 1 1|gap=30px|class_name=card|\n    <topic|\n    ## **Topic**{: .color-primary} (or hashtag)\n\n    <|{topic}|input|label=Automotive Topic (or hashtag)|>\n    |topic>\n\n    <mood|\n    ## **Mood**{: .color-primary}\n\n    <|{mood}|input|label=Mood (e.g. automotivenews, carreviews, automotiveinnovation) (optional)|>\n    |mood>\n\n    <style|\n    ## Twitter **account**{: .color-primary}\n\n    <|{style}|input|label=Twitter account handle to style-copy recent Automotive Tweets (optional)|>\n    |style>\n\n    Create a Generate text button\n    <|Generate Automotive Tweet|button|on_action=generate_text|label=Generate text|>\n\n    <image|part|render={prompt != \"\" and tweet != \"\" and image is not None}|class_name=card|\n    ### **Image**{: .color-primary} for Automotive\n\n    Display image\n    <center><|{image}|image|height=400px|></center>\n    |image>\n\n    Break line\n    <br/>\n\n    **Code from [@kinosal](https://twitter.com/kinosal)**\n\n    Original code can be found [here](https://github.com/kinosal/tweet)\n    |>\n    \"\"\"\n\n    Gui(page).run(dark_mode=False, port=5089)\n"}
{"text": "from taipy import Gui\nimport numpy as np\nfrom PIL import Image\nimport matplotlib.pyplot as plt\n\nWINDOW_SIZE = 500\n\ncm = plt.cm.get_cmap(\"viridis\")\n\n\ndef generate_mandelbrot(\n    center: int = WINDOW_SIZE / 2,\n    dx_range: int = 1000,\n    dx_start: float = -0.12,\n    dy_range: float = 1000,\n    dy_start: float = -0.82,\n    iterations: int = 50,\n    max_value: int = 200,\n    i: int = 0,\n) -> str:\n    mat = np.zeros((WINDOW_SIZE, WINDOW_SIZE))\n    for y in range(WINDOW_SIZE):\n        for x in range(WINDOW_SIZE):\n            dx = (x - center) / dx_range + dx_start\n            dy = (y - center) / dy_range + dy_start\n            a = dx\n            b = dy\n            for t in range(iterations):\n                d = (a * a) - (b * b) + dx\n                b = 2 * (a * b) + dy\n                a = d\n                h = d > max_value\n                if h is True:\n                    mat[x, y] = t\n\n    colored_mat = cm(mat / mat.max())\n    im = Image.fromarray((colored_mat * 255).astype(np.uint8))\n    path = f\"mandelbrot_{i}.png\"\n    im.save(path)\n\n    return path\n\n\ndef generate(state):\n    state.i = state.i + 1\n    state.path = generate_mandelbrot(\n        dx_start=-state.dx_start / 100,\n        dy_start=(state.dy_start - 100) / 100,\n        iterations=state.iterations,\n        i=state.i,\n    )\n\n\ni = 0\ndx_start = 11\ndy_start = 17\niterations = 50\n\npath = generate_mandelbrot(\n    dx_start=-dx_start / 100,\n    dy_start=(dy_start - 100) / 100,\n)\n\npage = \"\"\"\n# Mandelbrot Fractal for Logistics Visualization\n\n<|layout|columns=35 65|\nVisualize Complex Patterns with Mandelbrot Fractals\n<|{path}|image|width=500px|height=500px|class_name=img|>\n\nIterations:<br />\nSelect the number of iterations to explore fractal patterns\n<|{iterations}|slider|min=10|max=50|continuous=False|on_change=generate|><br />\nX Position:<br />\n<|{dy_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />\nY Position:<br />\n\nSlider dx_start\n<|{dx_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />\n|>\n\"\"\"\n\nGui(page).run(title=\"Mandelbrot Fractal for Logistics Visualization\")\n"}
{"text": "# **Country**{: .color-primary} Population Growth\n\n<|layout|columns=1 1 1|\n<|{selected_country_population}|selector|lov={selector_country_population}|on_change=on_change_country_population|dropdown|label=Country|>\n\n<|{selected_population_metric}|toggle|lov={population_metric_selector}|on_change=update_population_metric|>\n|>\n\n<br/>\n\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Total Population**{: .color-primary}\n<|{'{:,}'.format(int(population_data.iloc[-1]['Total Population']))}|text|class_name=h2|>\n|>\n\n<|card|\n**Urban Population**{: .color-primary}\n<|{'{:,}'.format(int(population_data.iloc[-1]['Urban Population']))}|text|class_name=h2|>\n|>\n\n<|card|\n**Rural Population**{: .color-primary}\n<|{'{:,}'.format(int(population_data.iloc[-1]['Rural Population']))}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|layout|columns=2 1|\n<|{population_data}|chart|type=bar|x=Year|y[3]=Total Population|y[2]=Urban Population|y[1]=Rural Population|layout={layout}|options={options}|title=Population Trends|>\n\n<|{population_distribution_chart}|chart|type=pie|values=distribution_values|labels=distribution_labels|title=Urban vs Rural Population|>\n|>\n"}
{"text": "# **Stock**{: .color-primary} Market Overview\n\n<|layout|columns=1 1 1|\n<|{selected_stock}|selector|lov={selector_stock}|on_change=on_change_stock|dropdown|label=Stock|>\n\n<|{selected_indicator}|toggle|lov={indicator_selector}|on_change=update_indicator_display|>\n|>\n\n<br/>\n\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Market Value**{: .color-primary}\n<|{'${:,.2f}'.format(stock_data.iloc[-1]['Market Value'])}|text|class_name=h2|>\n|>\n\n<|card|\n**Volume**{: .color-primary}\n<|{'{:,}'.format(stock_data.iloc[-1]['Volume'])}|text|class_name=h2|>\n|>\n\n<|card|\n**Change (%)**{: .color-primary}\n<|{'{:+.2f}%'.format(stock_data.iloc[-1]['Change'])}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|layout|columns=2 1|\n<|{stock_data}|chart|type=line|x=Date|y[3]=Market Value|y[2]=Volume|y[1]=Change|layout={layout}|options={options}|title=Stock Performance|>\n\n<|{sector_distribution_chart}|chart|type=pie|values=sector_values|labels=sector_labels|title=Market Sector Distribution|>\n|>\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\n\n# Load the sales data\ndf = pd.read_excel(\n    io=\"data/supermarkt_sales.xlsx\",\n    engine=\"openpyxl\",\n    sheet_name=\"Sales\",\n    skiprows=3,\n    usecols=\"B:R\",\n    nrows=1000,\n)\n\n# Add 'hour' column to the dataframe\ndf[\"hour\"] = pd.to_datetime(df[\"Time\"], format=\"%H:%M:%S\").dt.hour\n\n# Initialize variables\ncities = list(df[\"City\"].unique())\ntypes = list(df[\"Customer_type\"].unique())\ngenders = list(df[\"Gender\"].unique())\ncity = cities\ncustomer_type = types\ngender = genders\n\nlayout = {\"margin\": {\"l\": 220}}\n\n# Markdown for the entire page\npage = \"\"\"<|toggle|theme|>\n\n<|layout|columns=20 80|gap=30px|\n<sidebar|\n## Please **filter**{: .orange} here:\n\n<|{city}|selector|lov={cities}|multiple|label=Select the City|dropdown|on_change=on_filter|width=100%|>\n\n<|{customer_type}|selector|lov={types}|multiple|label=Select the Customer Type|dropdown|on_change=on_filter|width=100%|>\n\n<|{gender}|selector|lov={genders}|multiple|label=Select the Gender|dropdown|on_change=on_filter|width=100%|>\n|sidebar>\n\n<main_page|\n# \ud83d\udcca **Sales**{: .orange} Dashboard\n\n<|layout|columns=1 1 1|\n<total_sales|\n## **Total**{: .orange} sales:\n### US $ <|{int(df_selection[\"Total\"].sum())}|>\n|total_sales>\n\n<average_rating|\n## **Average**{: .orange} Rating:\n### <|{round(df_selection[\"Rating\"].mean(), 1)}|> <|{\"\u2b50\" * int(round(round(df_selection[\"Rating\"].mean(), 1), 0))}|>\n|average_rating>\n\n<average_sale|\n## Average Sales Per **Transaction**{: .orange}:\n### US $ <|{round(df_selection[\"Total\"].mean(), 2)}|>\n|average_sale>\n|>\n\n<br/>\n\nDisplay df_selection in an expandable\n<|Sales Table|expandable|expanded=False|\n<|{df_selection}|table|width=100%|page_size=5|rebuild|class_name=table|>\n|>\n\n<charts|\n<|{sales_by_hour}|chart|x=Hour|y=Total|type=bar|title=Sales by Hour|color=#ff462b|>\n\n<|{sales_by_product_line}|chart|x=Total|y=Product|type=bar|orientation=h|title=Sales by Product|layout={layout}|color=#ff462b|>\n|charts>\n|main_page>\n|>\n\nCode from [Coding is Fun](https://github.com/Sven-Bo)\n\nGet the Taipy Code [here](https://github.com/Avaiga/demo-sales-dashboard) and the original code [here](https://github.com/Sven-Bo/streamlit-sales-dashboard)\n\"\"\"\n\n\ndef filter(city, customer_type, gender):\n    df_selection = df[\n        df[\"City\"].isin(city)\n        & df[\"Customer_type\"].isin(customer_type)\n        & df[\"Gender\"].isin(gender)\n    ]\n\n    # SALES BY PRODUCT LINE [BAR CHART]\n    sales_by_product_line = (\n        df_selection[[\"Product line\", \"Total\"]]\n        .groupby(by=[\"Product line\"])\n        .sum()[[\"Total\"]]\n        .sort_values(by=\"Total\")\n    )\n    sales_by_product_line[\"Product\"] = sales_by_product_line.index\n\n    # SALES BY HOUR [BAR CHART]\n    sales_by_hour = (\n        df_selection[[\"hour\", \"Total\"]].groupby(by=[\"hour\"]).sum()[[\"Total\"]]\n    )\n    sales_by_hour[\"Hour\"] = sales_by_hour.index\n    return df_selection, sales_by_product_line, sales_by_hour\n\n\ndef on_filter(state):\n    state.df_selection, state.sales_by_product_line, state.sales_by_hour = filter(\n        state.city, state.customer_type, state.gender\n    )\n\n\nif __name__ == \"__main__\":\n    # Initialize dataframes\n    df_selection, sales_by_product_line, sales_by_hour = filter(\n        city, customer_type, gender\n    )\n\n    # Run the app\n    Gui(page).run()\n"}
{"text": "# **Country**{: .color-primary} Health Indicators\n\n<|layout|columns=1 1 1|\n<|{selected_country_health}|selector|lov={selector_country_health}|on_change=on_change_country_health|dropdown|label=Country|>\n\n<|{selected_health_metric}|toggle|lov={health_metric_selector}|on_change=update_health_metric_display|>\n|>\n\n<br/>\n\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Life Expectancy**{: .color-primary}\n<|{'{:.2f}'.format(health_data.iloc[-1]['Life Expectancy'])}|text|class_name=h2|>\n|>\n\n<|card|\n**Infant Mortality Rate**{: .color-primary}\n<|{'{:.2f}'.format(health_data.iloc[-1]['Infant Mortality'])}|text|class_name=h2|>\n|>\n\n<|card|\n**Healthcare Expenditure**{: .color-primary}\n<|{'${:,.2f}'.format(health_data.iloc[-1]['Expenditure'])}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|layout|columns=2 1|\n<|{health_data}|chart|type=line|x=Year|y[3]=Life Expectancy|y[2]=Infant Mortality|y[1]=Expenditure|layout={layout}|options={options}|title=Healthcare Trends|>\n\n<|{healthcare_distribution_chart}|chart|type=pie|values=healthcare_values|labels=healthcare_labels|title=Healthcare Distribution|>\n|>\n"}
{"text": "# **Worldwide**{: .color-primary} Space Exploration\n\n<br/>\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Space Missions**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_world_space['Missions']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n\n<|card|\n**Satellites Launched**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_world_space['Satellites']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n\n<|part|class_name=card|\n**Budget for Space Programs**{: .color-primary}\n<|{'${:,.2f}'.format(np.sum(data_world_space['Budget']))}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|{selected_space_metric}|toggle|lov={space_metric_selector}|>\n\n<|part|render={selected_space_metric=='Absolute'}|\n<|layout|columns=1 2|\n<|{data_world_space_pie_absolute}|chart|type=pie|labels=Country|values=Missions|title=Global Space Missions|>\n\n<|{data_world_space_evolution_absolute}|chart|properties={data_world_space_evolution_properties}|title=Space Exploration Trends|>\n|>\n|>\n\n<|part|render={selected_space_metric=='Relative'}|\n<|layout|columns=1 2|\n<|{data_world_space_pie_relative}|chart|type=pie|labels=Country|values=Satellites|>\n\n<|{data_world_space_evolution_relative}|chart|properties={data_world_space_evolution_relative_properties}|>\n|>\n|>\n"}
{"text": "if __name__ == \"__main__\":\n    # Initialize with custom sector-related values\n    topic = \"Education\"\n    mood = \"educational\"\n    style = \"educationexpert\"\n\n    # Create a GUI page with custom settings\n    page = \"\"\"\n    <|container|\n    # **Generate**{: .color-primary} Education Tweets\n\n    This mini-app generates Tweets related to Education 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    <br/>\n\n    <|layout|columns=1 1 1|gap=30px|class_name=card|\n    <topic|\n    ## **Topic**{: .color-primary} (or hashtag)\n\n    <|{topic}|input|label=Education Topic (or hashtag)|>\n    |topic>\n\n    <mood|\n    ## **Mood**{: .color-primary}\n\n    <|{mood}|input|label=Mood (e.g. educational, informative, learning) (optional)|>\n    |mood>\n\n    <style|\n    ## Twitter **account**{: .color-primary}\n\n    <|{style}|input|label=Twitter account handle to style-copy recent Education Tweets (optional)|>\n    |style>\n\n    Create a Generate text button\n    <|Generate Education Tweet|button|on_action=generate_text|label=Generate text|>\n\n    <image|part|render={prompt != \"\" and tweet != \"\" and image is not None}|class_name=card|\n    ### **Image**{: .color-primary} for Education\n\n    Display image\n    <center><|{image}|image|height=400px|></center>\n    |image>\n\n    Break line\n    <br/>\n\n    **Code from [@kinosal](https://twitter.com/kinosal)**\n\n    Original code can be found [here](https://github.com/kinosal/tweet)\n    |>\n    \"\"\"\n\n    Gui(page).run(dark_mode=False, port=5089)\n"}
{"text": "from taipy.gui import Gui\nimport taipy as tp\n\n# Import pages for the energy sector\nfrom pages.energy.dashboard import dashboard_md\nfrom pages.energy.consumption import consumption_md\nfrom pages.energy.production import production_md\nfrom pages.energy.renewables import renewables_md\n\n# Define your pages dictionary\npages = {\n    '/dashboard': dashboard_md,\n    '/consumption': consumption_md,\n    '/production': production_md,\n    '/renewables': renewables_md\n}\n\n# Create a Gui with your pages\ngui_energy = Gui(pages=pages)\n\nif __name__ == '__main__':\n    tp.Core().run()\n    \n    # Run the multi-page app\n    gui_energy.run(title=\"Energy Dashboard\")\n"}
{"text": "<|layout|columns=2 9|gap=50px|\n<sidebar|sidebar|\n**Traffic Analysis** Setup\n\n<|{selected_traffic_scenario}|traffic_scenario_selector|>\n|sidebar>\n\n<traffic_scenario|part|render={selected_traffic_scenario}|\n# **Traffic Flow Prediction**{: .color-primary} page\n\n<|1 1|layout|\n<date|\n#### Prediction **Date**{: .color-primary}\n\n<|{prediction_date}|date|on_change=on_change_traffic_params|>\n|date>\n\n<area|\n#### **Area**{: .color-primary} of Prediction\n\n<|{selected_area}|selector|lov={selector_area}|dropdown|on_change=on_change_traffic_params|label=Area|>\n|area>\n|>\n\n<|{selected_traffic_scenario}|traffic_scenario|on_submission_change=on_traffic_scenario_submission_change|not expanded|>\n\n---------------------------------------\n\n## **Traffic Predictions**{: .color-primary} and Data Visualization\n\n<|{selected_traffic_scenario.result.read() if selected_traffic_scenario and selected_traffic_scenario.result.read() is not None else default_traffic_result}|chart|x=Time|y[1]=Vehicle Count|y[2]=Congestion Level|type[1]=line|title=Traffic Forecast|>\n\n<|Data Nodes|expandable|\n<|1 5|layout|\n<|{selected_data_node}|data_node_selector|> \n\n<|{selected_data_node}|data_node|>\n|>\n|>\n\n|traffic_scenario>\n|>\n"}
{"text": "# **City**{: .color-primary} Urban Development Index\n\n<|layout|columns=1 1 1|\n<|{selected_city_development}|selector|lov={selector_city_development}|on_change=on_change_city_development|dropdown|label=City|>\n\n<|{selected_development_aspect}|toggle|lov={development_aspect_selector}|on_change=update_development_aspect_display|>\n|>\n\n<br/>\n\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Population Growth**{: .color-primary}\n<|{'{:.2f}%'.format(development_data.iloc[-1]['Population Growth'])}|text|class_name=h2|>\n|>\n\n<|card|\n**Infrastructure Rating**{: .color-primary}\n<|{'{:.2f}'.format(development_data.iloc[-1]['Infrastructure'])}|text|class_name=h2|>\n|>\n\n<|card|\n**Economic Activity**{: .color-primary}\n<|{'{:.2f}'.format(development_data.iloc[-1]['Economic Activity'])}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|layout|columns=2 1|\n<|{development_data}|chart|type=bar|x=Year|y[3]=Population Growth|y[2]=Infrastructure|y[1]=Economic Activity|layout={layout}|options={options}|title=Urban Development Trends|>\n\n<|{development_aspect_chart}|chart|type=pie|values=development_aspect_values|labels=development_aspect_labels|title=Aspect Distribution|>\n|>\n"}
{"text": "<|layout|columns=2 9|gap=50px|\n<sidebar|sidebar|\n**Performance Analysis** Setup\n\n<|{selected_educational_scenario}|educational_scenario_selector|>\n|sidebar>\n\n<educational_scenario|part|render={selected_educational_scenario}|\n# **Student Performance Prediction**{: .color-primary} page\n\n<|1 1|layout|\n<date|\n#### Analysis **Date**{: .color-primary}\n\n<|{analysis_date}|date|on_change=on_change_educational_params|>\n|date>\n\n<school|\n#### **School**{: .color-primary} for Analysis\n\n<|{selected_school}|selector|lov={selector_school}|dropdown|on_change=on_change_educational_params|label=School|>\n|school>\n|>\n\n<|{selected_educational_scenario}|educational_scenario|on_submission_change=on_educational_scenario_submission_change|not expanded|>\n\n---------------------------------------\n\n## **Student Performance Trends**{: .color-primary} and Insights\n\n<|{selected_educational_scenario.result.read() if selected_educational_scenario and selected_educational_scenario.result.read() is not None else default_educational_result}|chart|x=Subject|y[1]=Average Score|y[2]=Grade Level|type[1]=bar|title=Academic Performance|>\n\n<|Data Nodes|expandable|\n<|1 5|layout|\n<|{selected_data_node}|data_node_selector|> \n\n<|{selected_data_node}|data_node|>\n|>\n|>\n\n|educational_scenario>\n|>\n"}
{"text": "<|layout|columns=1 1|\n<|part|class_name=card|\n### Select Patient Group<br/>\n<|{patient_group_selected}|selector|lov=group_diabetes;group_cardio;group_respiratory|dropdown|on_change=on_patient_group_change|>\n|>\n\n<|part|class_name=card|\n### Select Comparison Group<br/>\n<|{comparison_group_selected}|selector|lov=group_diabetes;group_cardio;group_respiratory|dropdown|on_change=on_comparison_group_change|>\n|>\n\n|>\n\n<|Patient Data Overview|expandable|expanded=True|\nDisplay patient_group_data and comparison_group_data\n<|layout|columns=1 1|\n<|{patient_group_data}|table|page_size=5|>\n\n<|{comparison_group_data}|table|page_size=5|>\n|>\n|>\n\n<|layout|columns=1 1|\n<|part|class_name=card|\n<|{age_distribution_chart}|chart|type=bar|x=Age Group|y=Patients|title=Age Distribution|>\n|>\n\n<|part|class_name=card|\n<|{disease_prevalence_chart}|chart|type=pie|options={disease_options}|\n"}
{"text": "if __name__ == \"__main__\":\n    # Initialize with custom sector-related values\n    topic = \"Logistics\"\n    mood = \"supplychain\"\n    style = \"logisticsexpert\"\n\n    # Create a GUI page with custom settings\n    page = \"\"\"\n    <|container|\n    # **Generate**{: .color-primary} Logistics Tweets\n\n    This mini-app generates Tweets related to Logistics 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    <br/>\n\n    <|layout|columns=1 1 1|gap=30px|class_name=card|\n    <topic|\n    ## **Topic**{: .color-primary} (or hashtag)\n\n    <|{topic}|input|label=Logistics Topic (or hashtag)|>\n    |topic>\n\n    <mood|\n    ## **Mood**{: .color-primary}\n\n    <|{mood}|input|label=Mood (e.g. supplychain, shipping, logistics) (optional)|>\n    |mood>\n\n    <style|\n    ## Twitter **account**{: .color-primary}\n\n    <|{style}|input|label=Twitter account handle to style-copy recent Logistics Tweets (optional)|>\n    |style>\n\n    Create a Generate text button\n    <|Generate Logistics Tweet|button|on_action=generate_text|label=Generate text|>\n\n    <image|part|render={prompt != \"\" and tweet != \"\" and image is not None}|class_name=card|\n    ### **Image**{: .color-primary} for Logistics\n\n    Display image\n    <center><|{image}|image|height=400px|></center>\n    |image>\n\n    Break line\n    <br/>\n\n    **Code from [@kinosal](https://twitter.com/kinosal)**\n\n    Original code can be found [here](https://github.com/kinosal/tweet)\n    |>\n    \"\"\"\n\n    Gui(page).run(dark_mode=False, port=5089)\n"}
{"text": "<|layout|columns=1 1|\n<|part|class_name=card|\n### Select Team<br/>\n<|{team_selected}|selector|lov=team_lakers;team_warriors;team_celtics|dropdown|on_change=on_team_change|>\n|>\n\n<|part|class_name=card|\n### Select Season<br/>\n<|{season_selected}|selector|lov=season_2020;season_2021;season_2022|dropdown|on_change=on_season_change|>\n|>\n\n|>\n\n<|Team Performance Overview|expandable|expanded=True|\nDisplay team_data and season_data\n<|layout|columns=1 1|\n<|{team_data}|table|page_size=5|>\n\n<|{season_data}|table|page_size=5|>\n|>\n|>\n\n<|layout|columns=1 1|\n<|part|class_name=card|\n<|{player_stats_chart}|chart|type=bar|x=Player|y=Points|title=Player Performance|>\n|>\n\n<|part|class_name=card|\n<|{win_loss_chart}|chart|type=line|x=Game|y=Win/Loss|title=Win-Loss Record|>\n|>\n|>\n\n<br/>\n### Analyze Team Dynamics:\n<|{team_dynamics_analysis}|scenario|on_submission_change=on_team_dynamics_status_change|expandable=False|expanded=False|>\n\n<|{team_dynamics_analysis}|scenario_dag|>\n\n<br/>\n### View team dynamics results:\n<|{team_dynamics_analysis.results if team_dynamics_analysis else None}|data_node|>\n"}
{"text": "if __name__ == \"__main__\":\n    # Initialize with custom sector-related values\n    topic = \"Technology\"\n    mood = \"innovative\"\n    style = \"techgiant\"\n\n    # Create a GUI page with custom settings\n    page = \"\"\"\n    <|container|\n    # **Generate**{: .color-primary} Technology Tweets\n\n    This mini-app generates Tweets related to Technology 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    <br/>\n\n    <|layout|columns=1 1 1|gap=30px|class_name=card|\n    <topic|\n    ## **Topic**{: .color-primary} (or hashtag)\n\n    <|{topic}|input|label=Technology Topic (or hashtag)|>\n    |topic>\n\n    <mood|\n    ## **Mood**{: .color-primary}\n\n    <|{mood}|input|label=Mood (e.g. innovative, futuristic, informative) (optional)|>\n    |mood>\n\n    <style|\n    ## Twitter **account**{: .color-primary}\n\n    <|{style}|input|label=Twitter account handle to style-copy recent Tech Tweets (optional)|>\n    |style>\n\n    Create a Generate text button\n    <|Generate Technology Tweet|button|on_action=generate_text|label=Generate text|>\n\n    <image|part|render={prompt != \"\" and tweet != \"\" and image is not None}|class_name=card|\n    ### **Image**{: .color-primary} for Technology\n\n    Display image\n    <center><|{image}|image|height=400px|></center>\n    |image>\n\n    Break line\n    <br/>\n\n    **Code from [@kinosal](https://twitter.com/kinosal)**\n\n    Original code can be found [here](https://github.com/kinosal/tweet)\n    |>\n    \"\"\"\n\n    Gui(page).run(dark_mode=False, port=5089)\n"}
{"text": "# **Global**{: .color-primary} Environmental Statistics\n\n<br/>\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Carbon Emissions**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_global_environment['Emissions']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n\n<|card|\n**Deforestation**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_global_environment['Deforestation']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n\n<|part|class_name=card|\n**Renewable Energy Usage**{: .color-primary}\n<|{'{:,}'.format(int(np.sum(data_global_environment['Renewable Energy']))).replace(',', ' ')}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|{selected_metric}|toggle|lov={metric_selector}|>\n\n<|part|render={selected_metric=='Absolute'}|\n<|layout|columns=1 2|\n<|{data_global_pie_absolute}|chart|type=pie|labels=Country|values=Emissions|title=Emissions Distribution Worldwide|>\n\n<|{data_global_environment_evolution_absolute}|chart|properties={data_global_environment_evolution_properties}|title=Environmental Trends Worldwide|>\n|>\n|>\n\n<|part|render={selected_metric=='Relative'}|\n<|layout|columns=1 2|\n<|{data_global_pie_relative}|chart|type=pie|labels=Country|values=Deforestation|>\n\n<|{data_global_environment_evolution_relative}|chart|properties={data_global_environment_evolution_relative_properties}|>\n|>\n|>\n"}
{"text": "from taipy.gui import Gui\nimport open3d as o3d\nimport numpy as np\n\nmodel_data = None\nmodel_path = \"\"\n\ndef model_upload_view(state):\n    if state.model_path:\n        model = o3d.io.read_triangle_mesh(state.model_path)\n        state.model_data = np.asarray(model.vertices)\n\nmodel_view_page = \"\"\"\n<|{model_path}|file_selector|accept=.ply,.stl|on_action=model_upload_view|>\n<|{model_data}|viewer3d|>\n\"\"\"\n\nGui(model_view_page).run()\n"}
{"text": "from taipy import Gui\nimport numpy as np\nfrom PIL import Image\nimport matplotlib.pyplot as plt\n\nWINDOW_SIZE = 500\n\ncm = plt.cm.get_cmap(\"viridis\")\n\n\ndef generate_mandelbrot(\n    center: int = WINDOW_SIZE / 2,\n    dx_range: int = 1000,\n    dx_start: float = -0.12,\n    dy_range: float = 1000,\n    dy_start: float = -0.82,\n    iterations: int = 50,\n    max_value: int = 200,\n    i: int = 0,\n) -> str:\n    mat = np.zeros((WINDOW_SIZE, WINDOW_SIZE))\n    for y in range(WINDOW_SIZE):\n        for x in range(WINDOW_SIZE):\n            dx = (x - center) / dx_range + dx_start\n            dy = (y - center) / dy_range + dy_start\n            a = dx\n            b = dy\n            for t in range(iterations):\n                d = (a * a) - (b * b) + dx\n                b = 2 * (a * b) + dy\n                a = d\n                h = d > max_value\n                if h is True:\n                    mat[x, y] = t\n\n    colored_mat = cm(mat / mat.max())\n    im = Image.fromarray((colored_mat * 255).astype(np.uint8))\n    path = f\"mandelbrot_{i}.png\"\n    im.save(path)\n\n    return path\n\n\ndef generate(state):\n    state.i = state.i + 1\n    state.path = generate_mandelbrot(\n        dx_start=-state.dx_start / 100,\n        dy_start=(state.dy_start - 100) / 100,\n        iterations=state.iterations,\n        i=state.i,\n    )\n\n\ni = 0\ndx_start = 11\ndy_start = 17\niterations = 50\n\npath = generate_mandelbrot(\n    dx_start=-dx_start / 100,\n    dy_start=(dy_start - 100) / 100,\n)\n\npage = \"\"\"\n# Mandelbrot Fractal for Financial Visualization\n\n<|layout|columns=35 65|\nVisualize Complex Patterns with Mandelbrot Fractals\n<|{path}|image|width=500px|height=500px|class_name=img|>\n\nIterations:<br />\nSelect the number of iterations to explore fractal patterns\n<|{iterations}|slider|min=10|max=50|continuous=False|on_change=generate|><br />\nX Position:<br />\n<|{dy_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />\nY Position:<br />\n\nSlider dx_start\n<|{dx_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />\n|>\n\"\"\"\n\nGui(page).run(title=\"Mandelbrot Fractal for Financial Visualization\")\n"}
{"text": "<|{all_feedback}|table|columns={feedback_columns}|width='100%'|on_action={on_feedback_select}|style=feedback_style|>\n<|Add Feedback|button|on_action={open_add_feedback_dialog}|>\n<|Refresh Feedback|button|on_action={refresh_feedback_list}|>\n\n<|{show_add_feedback_dialog}|dialog|title=Submit New Feedback|\n<|{customer_name}|input|placeholder='Customer Name'|\n<|{feedback_content}|textarea|placeholder='Enter feedback here...'|\n<|Submit|button|on_action={submit_feedback}|>\n<|Cancel|button|on_action={close_add_feedback_dialog}|>\n|>\n\n<|{show_feedback_details}|pane|\n\n# Feedback Details <|Archive|button|on_action=archive_selected_feedback|>\n\n<|layout|columns=1|\n<|part|class_name=card|\n## Customer Name\n<|{selected_feedback.customer_name}|>\n|>\n\n<|part|class_name=card|\n## Feedback\n<|{selected_feedback.content}|textarea|disabled=True|>\n|>\n\n<|part|class_name=card|\n## Submission Date\n<|{selected_feedback.date.strftime(\"%b %d, %Y at %H:%M:%S\")}|>\n|>\n\n----\n|>\n"}
{"text": "from taipy import Gui\nimport numpy as np\nfrom PIL import Image\nimport matplotlib.pyplot as plt\n\nWINDOW_SIZE = 500\n\ncm = plt.cm.get_cmap(\"viridis\")\n\n\ndef generate_mandelbrot(\n    center: int = WINDOW_SIZE / 2,\n    dx_range: int = 1000,\n    dx_start: float = -0.12,\n    dy_range: float = 1000,\n    dy_start: float = -0.82,\n    iterations: int = 50,\n    max_value: int = 200,\n    i: int = 0,\n) -> str:\n    mat = np.zeros((WINDOW_SIZE, WINDOW_SIZE))\n    for y in range(WINDOW_SIZE):\n        for x in range(WINDOW_SIZE):\n            dx = (x - center) / dx_range + dx_start\n            dy = (y - center) / dy_range + dy_start\n            a = dx\n            b = dy\n            for t in range(iterations):\n                d = (a * a) - (b * b) + dx\n                b = 2 * (a * b) + dy\n                a = d\n                h = d > max_value\n                if h is True:\n                    mat[x, y] = t\n\n    colored_mat = cm(mat / mat.max())\n    im = Image.fromarray((colored_mat * 255).astype(np.uint8))\n    path = f\"mandelbrot_{i}.png\"\n    im.save(path)\n\n    return path\n\n\ndef generate(state):\n    state.i = state.i + 1\n    state.path = generate_mandelbrot(\n        dx_start=-state.dx_start / 100,\n        dy_start=(state.dy_start - 100) / 100,\n        iterations=state.iterations,\n        i=state.i,\n    )\n\n\ni = 0\ndx_start = 11\ndy_start = 17\niterations = 50\n\npath = generate_mandelbrot(\n    dx_start=-dx_start / 100,\n    dy_start=(dy_start - 100) / 100,\n)\n\npage = \"\"\"\n# Mandelbrot Fractal for Sports Visualization\n\n<|layout|columns=35 65|\nVisualize Complex Patterns with Mandelbrot Fractals\n<|{path}|image|width=500px|height=500px|class_name=img|>\n\nIterations:<br />\nSelect the number of iterations to explore fractal patterns\n<|{iterations}|slider|min=10|max=50|continuous=False|on_change=generate|><br />\nX Position:<br />\n<|{dy_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />\nY Position:<br />\n\nSlider dx_start\n<|{dx_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />\n|>\n\"\"\"\n\nGui(page).run(title=\"Mandelbrot Fractal for Sports Visualization\")\n"}
{"text": "<|{all_vehicles}|table|columns={vehicle_columns}|width='100%'|on_action={on_vehicle_select}|style=vehicle_style|>\n<|Log Maintenance|button|on_action={open_log_maintenance_dialog}|>\n<|Refresh Vehicles|button|on_action={refresh_vehicle_list}|>\n\n<|{show_log_maintenance_dialog}|dialog|title=Log Vehicle Maintenance|\n<|{vehicle_id}|selector|lov={get_all_vehicle_ids()}|>\n<|{maintenance_type}|input|placeholder='Maintenance Type'|\n<|{maintenance_date}|date_picker|>\n<|Log Maintenance|button|on_action={log_maintenance}|>\n<|Cancel|button|on_action={close_log_maintenance_dialog}|>\n|>\n\n<|{show_vehicle_details}|pane|\n\n# Vehicle Details <|Edit|button|on_action=edit_selected_vehicle|> <|Remove|button|on_action=remove_selected_vehicle|>\n\n<|layout|columns=1|\n<|part|class_name=card|\n## Vehicle ID\n<|{selected_vehicle.id}|>\n|>\n\n<|part|class_name=card|\n## Maintenance Type\n<|{selected_vehicle.maintenance_type}|>\n|>\n\n<|part|class_name=card|\n## Maintenance Date\n<|{selected_vehicle.maintenance_date.strftime(\"%b %d, %Y\")}|>\n|>\n\n----\n|>\n"}
{"text": "<|layout|columns=2 9|gap=50px|\n<sidebar|sidebar|\n**Resource Allocation** Planner\n\n<|{selected_healthcare_scenario}|healthcare_scenario_selector|>\n|sidebar>\n\n<healthcare_scenario|part|render={selected_healthcare_scenario}|\n# **Resource Distribution**{: .color-primary} page\n\n<|1 1|layout|\n<date|\n#### Effective **Date**{: .color-primary}\n\n<|{effective_date}|date|on_change=on_change_healthcare_params|>\n|date>\n\n<hospital|\n#### **Hospital**{: .color-primary} for Allocation\n\n<|{selected_hospital}|selector|lov={selector_hospital}|dropdown|on_change=on_change_healthcare_params|label=Hospital|>\n|hospital>\n|>\n\n<|{selected_healthcare_scenario}|healthcare_scenario|on_submission_change=on_healthcare_scenario_submission_change|not expanded|>\n\n---------------------------------------\n\n## **Resource Allocation**{: .color-primary} and Analysis\n\n<|{selected_healthcare_scenario.result.read() if selected_healthcare_scenario and selected_healthcare_scenario.result.read() is not None else default_resource_allocation}|chart|x=Resource|y[1]=Allocated|y[2]=Required|type[1]=bar|title=Healthcare Resource Allocation|>\n\n<|Data Nodes|expandable|\n<|1 5|layout|\n<|{selected_data_node}|data_node_selector|> \n\n<|{selected_data_node}|data_node|>\n|>\n|>\n\n|healthcare_scenario>\n|>\n"}
{"text": "from taipy.gui import Gui\nimport pandas as pd\n\n# Load inventory data\ninventory_data = pd.read_csv(\"inventory_data.csv\")\n\n# Initialize variables\ncategories = list(inventory_data[\"Category\"].unique())\nlocations = list(inventory_data[\"Location\"].unique())\ncategory = categories\nlocation = locations\n\n# Markdown for the entire page\npage = \"\"\"<|toggle|theme|>\n\n<|layout|columns=20 80|gap=30px|\n<sidebar|\n## **Filter**{: .orange} Inventory:\n\n<|{category}|selector|lov={categories}|multiple|label=Select Category|dropdown|on_change=on_filter|width=100%|>\n\n<|{location}|selector|lov={locations}|multiple|label=Select Location|dropdown|on_change=on_filter|width=100%|>\n|sidebar>\n\n<main_page|\n# Inventory Management System\n\n<|layout|columns=1 1 1|\n<total_items|\n## Total Items:\n### <|{len(df_selection)}|>\n|total_items>\n\n<average_price|\n## Average Price:\n### US $ <|{round(df_selection[\"Price\"].mean(), 2)}|>\n|average_price>\n\n<inventory_table|\nDisplay df_selection in an expandable\n<|Inventory Table|expandable|expanded=False|\n<|{df_selection}|table|width=100%|page_size=10|rebuild|class_name=table|>\n|inventory_table>\n|main_page>\n|>\n\nCode adapted from [Inventory Management](https://github.com/inventory_management_app)\n\nGet the Taipy Code [here](https://github.com/Avaiga/inventory-management-app)\n"}
{"text": "from taipy.gui import Gui\nimport fitz  # PyMuPDF\nimport io\n\npdf_data = None\npdf_path = \"\"\n\ndef pdf_upload(state):\n    if state.pdf_path:\n        pdf_doc = fitz.open(state.pdf_path)\n        page = pdf_doc.load_page(0)  # Display the first page\n        state.pdf_data = io.BytesIO(page.get_pixmap().tobytes(\"png\"))\n\npdf_page = \"\"\"\n<|{pdf_path}|file_selector|accept=.pdf|on_action=pdf_upload|>\n<|{pdf_data}|image|>\n\"\"\"\n\nGui(pdf_page).run()\n"}
{"text": "# **City**{: .color-primary} Environmental Data\n\n<|layout|columns=1 1 1|\n<|{selected_city}|selector|lov={selector_city}|on_change=on_change_city|dropdown|label=City|>\n\n<|{selected_pollutant}|toggle|lov={pollutant_selector}|on_change=update_pollutant_display|>\n|>\n\n<br/>\n\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Air Quality Index**{: .color-primary}\n<|{'{:,}'.format(int(city_data.iloc[-1]['AQI'])).replace(',', ' ')}|text|class_name=h2|>\n|>\n\n<|card|\n**Pollution Level**{: .color-primary}\n<|{city_data.iloc[-1]['Pollution Level']}|text|class_name=h2|>\n|>\n\n<|card|\n**Temperature**{: .color-primary}\n<|{'{:.1f}\u00b0C'.format(city_data.iloc[-1]['Temperature'])}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|layout|columns=2 1|\n<|{city_data}|chart|type=line|x=Date|y[3]=AQI|y[2]=Pollution Level|y[1]=Temperature|layout={layout}|options={options}|title=Environmental Trends|>\n\n<|{pollution_distribution_chart}|chart|type=pie|values=pollution_values|labels=pollution_labels|title=Pollution Source Distribution|>\n|>\n"}
{"text": "if __name__ == \"__main__\":\n    # Initialize with custom sector-related values\n    topic = \"Finance\"\n    mood = \"financial\"\n    style = \"financialexpert\"\n\n    # Create a GUI page with custom settings\n    page = \"\"\"\n    <|container|\n    # **Generate**{: .color-primary} Finance Tweets\n\n    This mini-app generates Tweets related to Finance 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    <br/>\n\n    <|layout|columns=1 1 1|gap=30px|class_name=card|\n    <topic|\n    ## **Topic**{: .color-primary} (or hashtag)\n\n    <|{topic}|input|label=Finance Topic (or hashtag)|>\n    |topic>\n\n    <mood|\n    ## **Mood**{: .color-primary}\n\n    <|{mood}|input|label=Mood (e.g. financial, investment, money) (optional)|>\n    |mood>\n\n    <style|\n    ## Twitter **account**{: .color-primary}\n\n    <|{style}|input|label=Twitter account handle to style-copy recent Finance Tweets (optional)|>\n    |style>\n\n    Create a Generate text button\n    <|Generate Finance Tweet|button|on_action=generate_text|label=Generate text|>\n\n    <image|part|render={prompt != \"\" and tweet != \"\" and image is not None}|class_name=card|\n    ### **Image**{: .color-primary} for Finance\n\n    Display image\n    <center><|{image}|image|height=400px|></center>\n    |image>\n\n    Break line\n    <br/>\n\n    **Code from [@kinosal](https://twitter.com/kinosal)**\n\n    Original code can be found [here](https://github.com/kinosal/tweet)\n    |>\n    \"\"\"\n\n"}
{"text": "# **City**{: .color-primary} Crime Statistics\n\n<|layout|columns=1 1 1|\n<|{selected_city_crime}|selector|lov={selector_city_crime}|on_change=on_change_city_crime|dropdown|label=City|>\n\n<|{selected_crime_type}|toggle|lov={crime_type_selector}|on_change=update_crime_type_display|>\n|>\n\n<br/>\n\n<|layout|columns=1 1 1 1|gap=50px|\n<|card|\n**Total Crimes**{: .color-primary}\n<|{'{:,}'.format(int(crime_data.iloc[-1]['Total']))}|text|class_name=h2|>\n|>\n\n<|card|\n**Violent Crimes**{: .color-primary}\n<|{'{:,}'.format(int(crime_data.iloc[-1]['Violent']))}|text|class_name=h2|>\n|>\n\n<|card|\n**Property Crimes**{: .color-primary}\n<|{'{:,}'.format(int(crime_data.iloc[-1]['Property']))}|text|class_name=h2|>\n|>\n|>\n\n<br/>\n\n<|layout|columns=2 1|\n<|{crime_data}|chart|type=bar|x=Year|y[3]=Total|y[2]=Violent|y[1]=Property|layout={layout}|options={options}|title=Crime Trends|>\n\n<|{crime_type_distribution_chart}|chart|type=pie|values=crime_type_values|labels=crime_type_labels|title=Crime Type Distribution|>\n|>\n"}
{"text": "<|layout|columns=2 9|gap=50px|\n<sidebar|sidebar|\n**Yield Forecast** Configuration\n\n<|{selected_yield_forecast}|yield_forecast_selector|>\n|sidebar>\n\n<yield_forecast|part|render={selected_yield_forecast}|\n# **Crop Yield Prediction**{: .color-primary} page\n\n<|1 1|layout|\n<date|\n#### Forecast **Start Date**{: .color-primary}\n\n<|{forecast_start_date}|date|on_change=on_change_yield_params|>\n|date>\n\n<crop|\n#### **Crop Type**{: .color-primary} for Forecast\n\n<|{selected_crop_type}|selector|lov={selector_crop_type}|dropdown|on_change=on_change_yield_params|label=Crop Type|>\n|crop>\n|>\n\n<|{selected_yield_forecast}|yield_forecast|on_submission_change=on_yield_forecast_submission_change|not expanded|>\n\n---------------------------------------\n\n## **Crop Yield Predictions**{: .color-primary} and Data Analysis\n\n<|{selected_yield_forecast.result.read() if selected_yield_forecast and selected_yield_forecast.result.read() is not None else default_yield_result}|chart|x=Date|y[1]=Predicted Yield|y[2]=Historical Yield|type[1]=bar|title=Crop Yield Forecast|>\n\n<|Data Nodes|expandable|\n<|1 5|layout|\n<|{selected_data_node}|data_node_selector|> \n\n<|{selected_data_node}|data_node|>\n|>\n|>\n\n|yield_forecast>\n|>\n"}
{"text": "<|layout|columns=1 1|\n<|part|class_name=card|\n### Select Sales Period<br/>\n<|{sales_period_selected}|selector|lov=period_last_month;period_last_quarter;period_last_year|dropdown|on_change=on_sales_period_change|>\n|>\n\n<|part|class_name=card|\n### Select Product Category<br/>\n<|{product_category_selected}|selector|lov=category_electronics;category_clothing;category_home_goods|dropdown|on_change=on_product_category_change|>\n|>\n\n|>\n\n<|Sales Data Overview|expandable|expanded=True|\nDisplay sales_data and category_data\n<|layout|columns=1 1|\n<|{sales_data}|table|page_size=5|>\n\n<|{category_data}|table|page_size=5|>\n|>\n|>\n\n<|layout|columns=1 1|\n<|part|class_name=card|\n<|{sales_volume_chart}|chart|type=line|x=Month|y=Sales Volume|title=Monthly Sales Volume|>\n|>\n\n<|part|class_name=card|\n<|{product_category_chart}|chart|type=pie|options={category_options}|layout={category_layout}|>\n|>\n|>\n\n<br/>\n### Analyze Sales Performance:\n<|{sales_performance}|scenario|on_submission_change=on_sales_performance_status_change|expandable=False|expanded=False|>\n\n<|{sales_performance}|scenario_dag|>\n\n<br/>\n### View the analysis results:\n<|{sales_performance.results if sales_performance else None}|data_node|>\n"}
{"text": "#!/usr/bin/env python    \"\"\"The setup script.\"\"\"  import json  import os    from setuptools import find_namespace_packages, find_packages, setup    with open(\"README.md\") as readme_file:      readme = readme_file.read()    with open(f\"src{os.sep}taipy{os.sep}core{os.sep}version.json\") as version_file:      version = json.load(version_file)      version_string = f'{version.get(\"major\", 0)}.{version.get(\"minor\", 0)}.{version.get(\"patch\", 0)}'      if vext := version.get(\"ext\"):          version_string = f\"{version_string}.{vext}\"    requirements = [      \"pyarrow>=10.0.1,<11.0\",      \"networkx>=2.6,<3.0\",      \"openpyxl>=3.1.2,<3.2\",      \"modin[dask]>=0.23.0,<1.0\",      \"pymongo[srv]>=4.2.0,<5.0\",      \"sqlalchemy>=2.0.16,<2.1\",      \"toml>=0.10,<0.11\",      \"taipy-config@git+https://git@github.com/Avaiga/taipy-config.git@develop\",  ]    test_requirements = [\"pytest>=3.8\"]    extras_require = {      \"fastparquet\": [\"fastparquet==2022.11.0\"],      \"mssql\": [\"pyodbc>=4,<4.1\"],      \"mysql\": [\"pymysql>1,<1.1\"],      \"postgresql\": [\"psycopg2>2.9,<2.10\"],  }    setup(      author=\"Avaiga\",      author_email=\"dev@taipy.io\",      python_requires=\">=3.8\",      classifiers=[          \"Intended Audience :: Developers\",          \"License :: OSI Approved :: Apache Software License\",          \"Natural Language :: English\",          \"Programming Language :: Python :: 3\",          \"Programming Language :: Python :: 3.8\",          \"Programming Language :: Python :: 3.9\",          \"Programming Language :: Python :: 3.10\",          \"Programming Language :: Python :: 3.11\",      ],      description=\"A Python library to build powerful and customized data-driven back-end applications.\",      install_requires=requirements,      long_description=readme,      long_description_content_type=\"text/markdown\",      license=\"Apache License 2.0\",      keywords=\"taipy-core\",      name=\"taipy-core\",      package_dir={\"\": \"src\"},      packages=find_namespace_packages(where=\"src\") + find_packages(include=[\"taipy\", \"taipy.core\", \"taipy.core.*\"]),      include_package_data=True,      test_suite=\"tests\",      tests_require=test_requirements,      url=\"https://github.com/avaiga/taipy-core\",      version=version_string,      zip_safe=False,      extras_require=extras_require,  ) "}
{"text": "\"\"\"Unit test package for taipy.\"\"\" "}
{"text": "import pytest    from src.taipy.core import Core  from src.taipy.core._orchestrator._dispatcher import _DevelopmentJobDispatcher, _StandaloneJobDispatcher  from src.taipy.core._orchestrator._orchestrator import _Orchestrator  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.exceptions.exceptions import CoreServiceIsAlreadyRunning  from taipy.config import Config  from taipy.config.exceptions.exceptions import ConfigurationUpdateBlocked      class TestCore:      def test_run_core_trigger_config_check(self, caplog):          Config.configure_data_node(id=\"d0\", storage_type=\"toto\")          with pytest.raises(SystemExit):              core = Core()              core.run()          expected_error_message = (              \"`storage_type` field of DataNodeConfig `d0` must be either csv, sql_table,\"              \" sql, mongo_collection, pickle, excel, generic, json, parquet, or in_memory.\"              ' Current value of property `storage_type` is \"toto\".'          )          assert expected_error_message in caplog.text          core.stop()        def test_run_core_as_a_service_development_mode(self):          _OrchestratorFactory._dispatcher = None            core = Core()          assert core._orchestrator is None          assert core._dispatcher is None          assert _OrchestratorFactory._dispatcher is None            core.run()          assert core._orchestrator is not None          assert core._orchestrator == _Orchestrator          assert _OrchestratorFactory._orchestrator is not None          assert _OrchestratorFactory._orchestrator == _Orchestrator          assert core._dispatcher is not None          assert isinstance(core._dispatcher, _DevelopmentJobDispatcher)          assert isinstance(_OrchestratorFactory._dispatcher, _DevelopmentJobDispatcher)          core.stop()        def test_run_core_as_a_service_standalone_mode(self):          _OrchestratorFactory._dispatcher = None            core = Core()          assert core._orchestrator is None            assert core._dispatcher is None          assert _OrchestratorFactory._dispatcher is None            Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)          core.run()          assert core._orchestrator is not None          assert core._orchestrator == _Orchestrator          assert _OrchestratorFactory._orchestrator is not None          assert _OrchestratorFactory._orchestrator == _Orchestrator          assert core._dispatcher is not None          assert isinstance(core._dispatcher, _StandaloneJobDispatcher)          assert isinstance(_OrchestratorFactory._dispatcher, _StandaloneJobDispatcher)          assert core._dispatcher.is_running()          assert _OrchestratorFactory._dispatcher.is_running()          core.stop()        def test_core_service_can_only_be_run_once(self):          core_instance_1 = Core()          core_instance_2 = Core()            core_instance_1.run()            with pytest.raises(CoreServiceIsAlreadyRunning):              core_instance_1.run()          with pytest.raises(CoreServiceIsAlreadyRunning):              core_instance_2.run()            # Stop the Core service and run it again should work          core_instance_1.stop()            core_instance_1.run()          core_instance_1.stop()          core_instance_2.run()          core_instance_2.stop()        def test_block_config_update_when_core_service_is_running_development_mode(self):          _OrchestratorFactory._dispatcher = None            core = Core()          core.run()          with pytest.raises(ConfigurationUpdateBlocked):              Config.configure_data_node(id=\"i1\")          core.stop()        def test_block_config_update_when_core_service_is_running_standalone_mode(self):          _OrchestratorFactory._dispatcher = None            core = Core()          Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)          core.run()          with pytest.raises(ConfigurationUpdateBlocked):              Config.configure_data_node(id=\"i1\")          core.stop() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import json  import os  from datetime import datetime, timedelta    import pytest    from src.taipy.core._repository._decoder import _Decoder  from src.taipy.core._repository._encoder import _Encoder      @pytest.fixture(scope=\"function\", autouse=True)  def create_and_delete_json_file():      test_json_file = {          \"name\": \"testing\",          \"date\": datetime(1991, 1, 1),          \"default_data\": \"data for testing encoder\",          \"validity_period\": timedelta(days=1),      }      with open(\"data.json\", \"w\") as f:          json.dump(test_json_file, f, ensure_ascii=False, indent=4, cls=_Encoder)      yield      os.unlink(\"data.json\")      def test_json_encoder():      with open(\"data.json\") as json_file:          data = json.load(json_file)          assert data[\"name\"] == \"testing\"          assert data[\"default_data\"] == \"data for testing encoder\"          assert data[\"date\"] == {              \"__type__\": \"Datetime\",              \"__value__\": \"1991-01-01T00:00:00\",          }          assert data[\"date\"].get(\"__type__\") == \"Datetime\"          assert data[\"date\"].get(\"__value__\") == \"1991-01-01T00:00:00\"      def test_json_decoder():      with open(\"data.json\") as json_file:          data = json.load(json_file, cls=_Decoder)          assert data[\"name\"] == \"testing\"          assert data[\"default_data\"] == \"data for testing encoder\"          assert data[\"date\"] == datetime(1991, 1, 1) "}
{"text": "import src.taipy.core.taipy as tp  from src.taipy.core.config import Config      def test_no_special_characters():      scenario_config = Config.configure_scenario(\"scenario_1\")        scenario = tp.create_scenario(scenario_config, name=\"martin\")      assert scenario.name == \"martin\"      scenarios = tp.get_scenarios()      assert len(scenarios) == 1      assert scenarios[0].name == \"martin\"      def test_many_special_characters():      scenario_config = Config.configure_scenario(\"scenario_1\")        special_characters = (          \"!#$%&'()*+,-./:;<=>?@[]^_`\\\\{\"          \"\u00bb\u00bc\u00bd\u00be\u00bf\u00c0\u00c1\u00c2\u00c3\u00c4\u00c5\u00c6\u00c7\u00c8\u00c9\u00ca\u00cb\u00cc\u00cd\u00ce\u00cf\u00d0\u00d1\u00d2\u00d3\u00d4\u00d5\u00d6\"          \"\u00d7\u00d8\u00d9\u00da\u00db\u00dc\u00dd\u00de\u00df\u00e0\u00e1\u00e2\u00e3\u00e4\u00e5\u00e6\u00e7\u00e8\u00e9\u00ea\u00eb\u00ec\u00ed\u00ee\u00ef\u00f0\u00f1\u00f2\"          \"\u00f3\u00f4\u00f5\u00f6\u00f7\u00f8\u00f9\u00fa\u00fb\u00fc\u00fd\u00fe\u00ff\u0100\u0101\u0102\u0103\u0104\u0105\u0106\u0107\u0108\u0109\u010a\u010b\u010c\u010d\u010e\"          \"\u010f\u0110\u0111\u0112\u0113\u0114\u0115\u0116\u0117\u0118\u0119\u011a\u011b\u011c\u011d\u011e\u011f\u0120\u0121\u0122\u0123\u0124\u0125\u0126\u0127\u0128\u0129\u012a\"          \"\u012b\u012c\u012d\u012e\u012f\u0130\u0132\u0133\u0134\u0135\u0136\u0137\u0138\u0139\u013a\u013b\u013c\u013d\u013e\u013f\u0140\u0141\u0142\u0143\u0144\u0145\u0146\u0147\"          \"\u0148\u0149\u014a\u014b\u014c\u014d\u014e\u014f\u0150\u0151\u0152\u0153\u0154\u0155\u0156\u0157\u0158\u0159\u015a\u015b\u015c\u015d\u015e\u015f\u0160\u0161\u0162\u0163\"          \"\u0164\u0165\u0166\u0167\u0168\u0169\u016a\u016b\u016c\u016d\u016e\u016f\u0170\u0171\u0172\u0173\u0174\u0175\u0176\u0177\u0178\u0179\u017a\u017b\u017c\u017d\u017e\u017f\"      )        scenario = tp.create_scenario(scenario_config, name=special_characters)      assert scenario.name == special_characters      scenarios = tp.get_scenarios()      assert len(scenarios) == 1      assert scenarios[0].name == special_characters "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import json  import os  import pathlib  import shutil    import pytest    from src.taipy.core.exceptions.exceptions import InvalidExportPath  from taipy.config.config import Config    from .mocks import MockConverter, MockFSRepository, MockModel, MockObj, MockSQLRepository      class TestRepositoriesStorage:      @pytest.mark.parametrize(          \"mock_repo,params\",          [              (MockFSRepository, {\"model_type\": MockModel, \"dir_name\": \"mock_model\", \"converter\": MockConverter}),              (MockSQLRepository, {\"model_type\": MockModel, \"converter\": MockConverter}),          ],      )      def test_save_and_fetch_model(self, mock_repo, params, init_sql_repo):          r = mock_repo(**params)          m = MockObj(\"uuid\", \"foo\")          r._save(m)            fetched_model = r._load(m.id)          assert m == fetched_model        @pytest.mark.parametrize(          \"mock_repo,params\",          [              (MockFSRepository, {\"model_type\": MockModel, \"dir_name\": \"mock_model\", \"converter\": MockConverter}),              (MockSQLRepository, {\"model_type\": MockModel, \"converter\": MockConverter}),          ],      )      def test_exists(self, mock_repo, params, init_sql_repo):          r = mock_repo(**params)          m = MockObj(\"uuid\", \"foo\")          r._save(m)            assert r._exists(m.id)          assert not r._exists(\"not-existed-model\")        @pytest.mark.parametrize(          \"mock_repo,params\",          [              (MockFSRepository, {\"model_type\": MockModel, \"dir_name\": \"mock_model\", \"converter\": MockConverter}),              (MockSQLRepository, {\"model_type\": MockModel, \"converter\": MockConverter}),          ],      )      def test_get_all(self, mock_repo, params, init_sql_repo):          objs = []          r = mock_repo(**params)          r._delete_all()            for i in range(5):              m = MockObj(f\"uuid-{i}\", f\"Foo{i}\")              objs.append(m)              r._save(m)          _objs = r._load_all()            assert len(_objs) == 5            for obj in _objs:              assert isinstance(obj, MockObj)          assert sorted(objs, key=lambda o: o.id) == sorted(_objs, key=lambda o: o.id)        @pytest.mark.parametrize(          \"mock_repo,params\",          [              (MockFSRepository, {\"model_type\": MockModel, \"dir_name\": \"mock_model\", \"converter\": MockConverter}),              (MockSQLRepository, {\"model_type\": MockModel, \"converter\": MockConverter}),          ],      )      def test_delete_all(self, mock_repo, params, init_sql_repo):          r = mock_repo(**params)          r._delete_all()            for i in range(5):              m = MockObj(f\"uuid-{i}\", f\"Foo{i}\")              r._save(m)            _models = r._load_all()          assert len(_models) == 5            r._delete_all()          _models = r._load_all()          assert len(_models) == 0        @pytest.mark.parametrize(          \"mock_repo,params\",          [              (MockFSRepository, {\"model_type\": MockModel, \"dir_name\": \"mock_model\", \"converter\": MockConverter}),              (MockSQLRepository, {\"model_type\": MockModel, \"converter\": MockConverter}),          ],      )      def test_delete_many(self, mock_repo, params, init_sql_repo):          r = mock_repo(**params)          r._delete_all()            for i in range(5):              m = MockObj(f\"uuid-{i}\", f\"Foo{i}\")              r._save(m)            _models = r._load_all()          assert len(_models) == 5          r._delete_many([\"uuid-0\", \"uuid-1\"])          _models = r._load_all()          assert len(_models) == 3        @pytest.mark.parametrize(          \"mock_repo,params\",          [              (MockFSRepository, {\"model_type\": MockModel, \"dir_name\": \"mock_model\", \"converter\": MockConverter}),              (MockSQLRepository, {\"model_type\": MockModel, \"converter\": MockConverter}),          ],      )      def test_search(self, mock_repo, params, init_sql_repo):          r = mock_repo(**params)          r._delete_all()            m = MockObj(\"uuid\", \"foo\")          r._save(m)            m1 = r._search(\"name\", \"bar\")          m2 = r._search(\"name\", \"foo\")            assert m1 == []          assert m2 == [m]        @pytest.mark.parametrize(          \"mock_repo,params\",          [              (MockFSRepository, {\"model_type\": MockModel, \"dir_name\": \"mock_model\", \"converter\": MockConverter}),              (MockSQLRepository, {\"model_type\": MockModel, \"converter\": MockConverter}),          ],      )      @pytest.mark.parametrize(\"export_path\", [\"tmp\"])      def test_export(self, mock_repo, params, export_path, init_sql_repo):          r = mock_repo(**params)            m = MockObj(\"uuid\", \"foo\")          r._save(m)            r._export(\"uuid\", export_path)          assert pathlib.Path(os.path.join(export_path, \"mock_model/uuid.json\")).exists()          with open(os.path.join(export_path, \"mock_model/uuid.json\"), \"r\") as exported_file:              exported_data = json.load(exported_file)              assert exported_data[\"id\"] == \"uuid\"              assert exported_data[\"name\"] == \"foo\"            # Export to same location again should work          r._export(\"uuid\", export_path)          assert pathlib.Path(os.path.join(export_path, \"mock_model/uuid.json\")).exists()            if mock_repo == MockFSRepository:              with pytest.raises(InvalidExportPath):                  r._export(\"uuid\", Config.core.storage_folder)            shutil.rmtree(export_path, ignore_errors=True) "}
{"text": "import dataclasses  import pathlib  from dataclasses import dataclass  from typing import Any, Dict, Optional    from sqlalchemy import Column, String, Table  from sqlalchemy.dialects import sqlite  from sqlalchemy.orm import declarative_base, registry  from sqlalchemy.schema import CreateTable    from src.taipy.core._repository._abstract_converter import _AbstractConverter  from src.taipy.core._repository._filesystem_repository import _FileSystemRepository  from src.taipy.core._repository._sql_repository import _SQLRepository  from src.taipy.core._version._version_manager import _VersionManager  from taipy.config.config import Config      class Base:      __allow_unmapped__ = True      Base = declarative_base(cls=Base)  # type: ignore  mapper_registry = registry()      @dataclass  class MockObj:      def __init__(self, id: str, name: str, version: Optional[str] = None) -> None:          self.id = id          self.name = name          if version:              self._version = version          else:              self._version = _VersionManager._get_latest_version()      @dataclass  class MockModel(Base):  # type: ignore      __table__ = Table(          \"mock_model\",          mapper_registry.metadata,          Column(\"id\", String(200), primary_key=True),          Column(\"name\", String(200)),          Column(\"version\", String(200)),      )      id: str      name: str      version: str        def to_dict(self):          return dataclasses.asdict(self)        @staticmethod      def from_dict(data: Dict[str, Any]):          return MockModel(id=data[\"id\"], name=data[\"name\"], version=data[\"version\"])        def _to_entity(self):          return MockObj(id=self.id, name=self.name, version=self.version)        @classmethod      def _from_entity(cls, entity: MockObj):          return MockModel(id=entity.id, name=entity.name, version=entity._version)        def to_list(self):          return [self.id, self.name, self.version]      class MockConverter(_AbstractConverter):      @classmethod      def _entity_to_model(cls, entity):          return MockModel(id=entity.id, name=entity.name, version=entity._version)        @classmethod      def _model_to_entity(cls, model):          return MockObj(id=model.id, name=model.name, version=model.version)      class MockFSRepository(_FileSystemRepository):      def __init__(self, **kwargs):          super().__init__(**kwargs)        @property      def _storage_folder(self) -> pathlib.Path:          return pathlib.Path(Config.core.storage_folder)  # type: ignore      class MockSQLRepository(_SQLRepository):      def __init__(self, **kwargs):          super().__init__(**kwargs)          self.db.execute(str(CreateTable(MockModel.__table__, if_not_exists=True).compile(dialect=sqlite.dialect()))) "}
{"text": "import pytest    from taipy.config.config import Config      def test_job_config():      assert Config.job_config.mode == \"development\"        job_c = Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)      assert job_c.mode == \"standalone\"      assert job_c.max_nb_of_workers == 2        assert Config.job_config.mode == \"standalone\"      assert Config.job_config.max_nb_of_workers == 2        Config.configure_job_executions(foo=\"bar\")      assert Config.job_config.foo == \"bar\"      def test_clean_config():      job_config = Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2, prop=\"foo\")        assert Config.job_config is job_config        job_config._clean()        # Check if the instance before and after _clean() is the same      assert Config.job_config is job_config        assert job_config.mode == \"development\"      assert job_config._config == {\"max_nb_of_workers\": 1}      assert job_config.properties == {} "}
{"text": "from taipy.config.config import Config      def migrate_pickle_path(dn):      dn.path = \"s1.pkl\"      def migrate_skippable(task):      task.skippable = True      def test_migration_config():      assert Config.migration_functions.migration_fcts == {}        data_nodes1 = Config.configure_data_node(\"data_nodes1\", \"pickle\")        migration_cfg = Config.add_migration_function(          target_version=\"1.0\",          config=data_nodes1,          migration_fct=migrate_pickle_path,      )        assert migration_cfg.migration_fcts == {\"1.0\": {\"data_nodes1\": migrate_pickle_path}}      assert migration_cfg.properties == {}        data_nodes2 = Config.configure_data_node(\"data_nodes2\", \"pickle\")        migration_cfg = Config.add_migration_function(          target_version=\"1.0\",          config=data_nodes2,          migration_fct=migrate_pickle_path,      )      assert migration_cfg.migration_fcts == {          \"1.0\": {\"data_nodes1\": migrate_pickle_path, \"data_nodes2\": migrate_pickle_path}      }      def test_clean_config():      assert Config.migration_functions.migration_fcts == {}        data_nodes1 = Config.configure_data_node(\"data_nodes1\", \"pickle\")      migration_cfg = Config.add_migration_function(          target_version=\"1.0\",          config=data_nodes1,          migration_fct=migrate_pickle_path,      )        assert migration_cfg.migration_fcts == {\"1.0\": {\"data_nodes1\": migrate_pickle_path}}      assert migration_cfg.properties == {}        migration_cfg._clean()        assert migration_cfg.migration_fcts == {}      assert migration_cfg._properties == {} "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from src.taipy.core.config import CoreSection  from src.taipy.core.config.data_node_config import DataNodeConfig  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.config.migration_config import MigrationConfig  from src.taipy.core.config.scenario_config import ScenarioConfig  from src.taipy.core.config.task_config import TaskConfig  from taipy.config._config import _Config  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from taipy.config.global_app.global_app_config import GlobalAppConfig      def _test_default_job_config(job_config: JobConfig):      assert job_config is not None      assert job_config.mode == JobConfig._DEFAULT_MODE      def _test_default_core_section(core_section: CoreSection):      assert core_section is not None      assert core_section.mode == CoreSection._DEFAULT_MODE      assert core_section.version_number == \"\"      assert not core_section.force      assert core_section.root_folder == \"./taipy/\"      assert core_section.storage_folder == \".data/\"      assert core_section.repository_type == \"filesystem\"      assert core_section.repository_properties == {}      assert len(core_section.properties) == 0      def _test_default_data_node_config(dn_config: DataNodeConfig):      assert dn_config is not None      assert dn_config.id is not None      assert dn_config.storage_type == \"pickle\"      assert dn_config.scope == Scope.SCENARIO      assert dn_config.validity_period is None      assert len(dn_config.properties) == 0  # type: ignore      def _test_default_task_config(task_config: TaskConfig):      assert task_config is not None      assert task_config.id is not None      assert task_config.input_configs == []      assert task_config.output_configs == []      assert task_config.function is None      assert not task_config.skippable      assert len(task_config.properties) == 0  # type: ignore      def _test_default_scenario_config(scenario_config: ScenarioConfig):      assert scenario_config is not None      assert scenario_config.id is not None      assert scenario_config.tasks == []      assert scenario_config.task_configs == []      assert scenario_config.additional_data_nodes == []      assert scenario_config.additional_data_node_configs == []      assert scenario_config.data_nodes == []      assert scenario_config.data_node_configs == []      assert scenario_config.sequences == {}      assert len(scenario_config.properties) == 0  # type: ignore      def _test_default_version_migration_config(version_migration_config: MigrationConfig):      assert version_migration_config is not None      assert version_migration_config.migration_fcts == {}      assert len(version_migration_config.properties) == 0  # type: ignore      def _test_default_global_app_config(global_config: GlobalAppConfig):      assert global_config is not None      assert not global_config.notification      assert len(global_config.properties) == 0      def test_default_configuration():      default_config = Config._default_config      assert default_config._global_config is not None      _test_default_global_app_config(default_config._global_config)      _test_default_global_app_config(Config.global_config)      _test_default_global_app_config(GlobalAppConfig().default_config())        assert default_config._unique_sections is not None      assert len(default_config._unique_sections) == 3      assert len(default_config._sections) == 3        _test_default_job_config(default_config._unique_sections[JobConfig.name])      _test_default_job_config(Config.job_config)      _test_default_job_config(JobConfig().default_config())        _test_default_version_migration_config(default_config._unique_sections[MigrationConfig.name])      _test_default_version_migration_config(Config.migration_functions)      _test_default_version_migration_config(MigrationConfig.default_config())        _test_default_core_section(default_config._unique_sections[CoreSection.name])      _test_default_core_section(Config.core)      _test_default_core_section(CoreSection().default_config())        _test_default_data_node_config(default_config._sections[DataNodeConfig.name][_Config.DEFAULT_KEY])      _test_default_data_node_config(Config.data_nodes[_Config.DEFAULT_KEY])      _test_default_data_node_config(DataNodeConfig.default_config())      assert len(default_config._sections[DataNodeConfig.name]) == 1      assert len(Config.data_nodes) == 1        _test_default_task_config(default_config._sections[TaskConfig.name][_Config.DEFAULT_KEY])      _test_default_task_config(Config.tasks[_Config.DEFAULT_KEY])      _test_default_task_config(TaskConfig.default_config())      assert len(default_config._sections[TaskConfig.name]) == 1      assert len(Config.tasks) == 1        _test_default_scenario_config(default_config._sections[ScenarioConfig.name][_Config.DEFAULT_KEY])      Config.scenarios[_Config.DEFAULT_KEY]      _test_default_scenario_config(Config.scenarios[_Config.DEFAULT_KEY])      _test_default_scenario_config(ScenarioConfig.default_config())      assert len(default_config._sections[ScenarioConfig.name]) == 1      assert len(Config.scenarios) == 1 "}
{"text": "from unittest.mock import patch    import pytest    from src.taipy.core._init_version import _read_version  from src.taipy.core.config.core_section import CoreSection  from src.taipy.core.exceptions import ConfigCoreVersionMismatched  from taipy.config.config import Config  from tests.core.utils.named_temporary_file import NamedTemporaryFile    _MOCK_CORE_VERSION = \"3.1.1\"      @pytest.fixture(scope=\"function\", autouse=True)  def mock_core_version():      with patch(\"src.taipy.core.config.core_section._read_version\") as mock_read_version:          mock_read_version.return_value = _MOCK_CORE_VERSION          CoreSection._CURRENT_CORE_VERSION = _MOCK_CORE_VERSION          Config.unique_sections[CoreSection.name] = CoreSection.default_config()          Config._default_config._unique_sections[CoreSection.name] = CoreSection.default_config()            yield      @pytest.fixture(scope=\"session\", autouse=True)  def reset_core_version():      yield      CoreSection._CURRENT_CORE_VERSION = _read_version()      class TestCoreVersionInCoreSectionConfig:      major, minor, patch = _MOCK_CORE_VERSION.split(\".\")        current_version = f\"{major}.{minor}.{patch}\"      current_dev_version = f\"{major}.{minor}.{patch}.dev0\"      compatible_future_version = f\"{major}.{minor}.{int(patch) + 1}\"      compatible_future_dev_version = f\"{major}.{minor}.{int(patch) + 1}.dev0\"        core_version_is_compatible = [          # Current version and dev version should be compatible          (f\"{major}.{minor}.{patch}\", True),          (f\"{major}.{minor}.{patch}.dev0\", True),          # Future versions with same major and minor should be compatible          (f\"{major}.{minor}.{int(patch) + 1}\", True),          (f\"{major}.{minor}.{int(patch) + 1}.dev0\", True),          # Past versions with same major and minor should be compatible          (f\"{major}.{minor}.{int(patch) - 1}\", True),          (f\"{major}.{minor}.{int(patch) - 1}.dev0\", True),          # Future versions with different minor number should be incompatible          (f\"{major}.{int(minor) + 1}.{patch}\", False),          (f\"{major}.{int(minor) + 1}.{patch}.dev0\", False),          # Past versions with different minor number should be incompatible          (f\"{major}.{int(minor) - 1}.{patch}\", False),          (f\"{major}.{int(minor) - 1}.{patch}.dev0\", False),      ]        @pytest.mark.parametrize(\"core_version, is_compatible\", core_version_is_compatible)      def test_load_configuration_file(self, core_version, is_compatible):          file_config = NamedTemporaryFile(              f\"\"\"              [TAIPY]                [JOB]              mode = \"standalone\"              max_nb_of_workers = \"2:int\"                [CORE]              root_folder = \"./taipy/\"              storage_folder = \".data/\"              repository_type = \"filesystem\"              read_entity_retry = \"0:int\"              mode = \"development\"              version_number = \"\"              force = \"False:bool\"              core_version = \"{core_version}\"                [VERSION_MIGRATION.migration_fcts]              \"\"\"          )          if is_compatible:              Config.load(file_config.filename)              assert Config.unique_sections[CoreSection.name]._core_version == _MOCK_CORE_VERSION          else:              with pytest.raises(ConfigCoreVersionMismatched):                  Config.load(file_config.filename)        @pytest.mark.parametrize(\"core_version,is_compatible\", core_version_is_compatible)      def test_override_configuration_file(self, core_version, is_compatible):          file_config = NamedTemporaryFile(              f\"\"\"              [TAIPY]                [JOB]              mode = \"standalone\"              max_nb_of_workers = \"2:int\"                [CORE]              root_folder = \"./taipy/\"              storage_folder = \".data/\"              repository_type = \"filesystem\"              read_entity_retry = \"0:int\"              mode = \"development\"              version_number = \"\"              force = \"False:bool\"              core_version = \"{core_version}\"                [VERSION_MIGRATION.migration_fcts]              \"\"\"          )          if is_compatible:              Config.override(file_config.filename)              assert Config.unique_sections[CoreSection.name]._core_version == _MOCK_CORE_VERSION          else:              with pytest.raises(ConfigCoreVersionMismatched):                  Config.override(file_config.filename)        def test_load_configuration_file_without_core_section(self):          file_config = NamedTemporaryFile(              \"\"\"              [TAIPY]              [JOB]              mode = \"standalone\"              max_nb_of_workers = \"2:int\"              [CORE]              root_folder = \"./taipy/\"              storage_folder = \".data/\"              repository_type = \"filesystem\"              read_entity_retry = \"0:int\"              mode = \"development\"              version_number = \"\"              force = \"False:bool\"              [VERSION_MIGRATION.migration_fcts]              \"\"\"          )          Config.load(file_config.filename)          assert Config.unique_sections[CoreSection.name]._core_version == _MOCK_CORE_VERSION "}
{"text": "from datetime import timedelta    from taipy.config import Config  from taipy.config.common.scope import Scope      class TestConfig:      def test_configure_csv_data_node(self):          a, b, c, d, e, f = \"foo\", \"path\", True, \"numpy\", Scope.SCENARIO, timedelta(1)          Config.configure_csv_data_node(a, b, c, d, e, f)          assert len(Config.data_nodes) == 2        def test_configure_excel_data_node(self):          a, b, c, d, e, f, g = \"foo\", \"path\", True, \"Sheet1\", \"numpy\", Scope.SCENARIO, timedelta(1)          Config.configure_excel_data_node(a, b, c, d, e, f, g)          assert len(Config.data_nodes) == 2        def test_configure_generic_data_node(self):          a, b, c, d, e, f, g, h = \"foo\", print, print, tuple([]), tuple([]), Scope.SCENARIO, timedelta(1), \"qux\"          Config.configure_generic_data_node(a, b, c, d, e, f, g, property=h)          assert len(Config.data_nodes) == 2        def test_configure_in_memory_data_node(self):          a, b, c, d, e = \"foo\", 0, Scope.SCENARIO, timedelta(1), \"qux\"          Config.configure_in_memory_data_node(a, b, c, d, property=e)          assert len(Config.data_nodes) == 2        def test_configure_pickle_data_node(self):          a, b, c, d, e = \"foo\", 0, Scope.SCENARIO, timedelta(1), \"path\"          Config.configure_pickle_data_node(a, b, c, d, path=e)          assert len(Config.data_nodes) == 2        def test_configure_json_data_node(self):          a, dp, ec, dc, sc, f, p = \"foo\", \"path\", \"ec\", \"dc\", Scope.SCENARIO, timedelta(1), \"qux\"          Config.configure_json_data_node(a, dp, ec, dc, sc, f, path=p)          assert len(Config.data_nodes) == 2        def test_configure_sql_table_data_node(self):          a, b, c, d, e, f, g, h, i, extra_args, exposed_type, scope, vp, k = (              \"foo\",              \"user\",              \"pwd\",              \"db\",              \"engine\",              \"table_name\",              \"port\",              \"host\",              \"driver\",              {\"foo\": \"bar\"},              \"exposed_type\",              Scope.SCENARIO,              timedelta(1),              \"qux\",          )          Config.configure_sql_table_data_node(a, b, c, d, e, f, g, h, i, extra_args, exposed_type, scope, vp, property=k)          assert len(Config.data_nodes) == 2        def test_configure_sql_data_node(self):          a, b, c, d, e, f, g, h, i, j, k, extra_args, exposed_type, scope, vp, k = (              \"foo\",              \"user\",              \"pwd\",              \"db\",              \"engine\",              \"read_query\",              \"write_query_builder\",              \"append_query_builder\",              \"port\",              \"host\",              \"driver\",              {\"foo\": \"bar\"},              \"exposed_type\",              Scope.SCENARIO,              timedelta(1),              \"qux\",          )          Config.configure_sql_data_node(a, b, c, d, e, f, g, h, i, j, k, extra_args, exposed_type, scope, vp, property=k)          assert len(Config.data_nodes) == 2        def test_configure_mongo_data_node(self):          a, b, c, d, e, f, g, h, extra_args, scope, vp, k = (              \"foo\",              \"db_name\",              \"collection_name\",              None,              \"user\",              \"pwd\",              \"host\",              \"port\",              {\"foo\": \"bar\"},              Scope.SCENARIO,              timedelta(1),              \"qux\",          )          Config.configure_mongo_collection_data_node(a, b, c, d, e, f, g, h, extra_args, scope, vp, property=k)          assert len(Config.data_nodes) == 2 "}
{"text": "from unittest.mock import patch    from src.taipy.core import Core  from src.taipy.core._version._version_manager_factory import _VersionManagerFactory  from taipy.config import Config  from tests.core.utils.named_temporary_file import NamedTemporaryFile      def test_core_section():      with patch(\"sys.argv\", [\"prog\"]):          core = Core()          core.run()      assert Config.core.mode == \"development\"      assert Config.core.version_number == _VersionManagerFactory._build_manager()._get_development_version()      assert not Config.core.force      core.stop()        with patch(\"sys.argv\", [\"prog\"]):          Config.configure_core(mode=\"experiment\", version_number=\"test_num\", force=True)          core = Core()          core.run()      assert Config.core.mode == \"experiment\"      assert Config.core.version_number == \"test_num\"      assert Config.core.force      core.stop()        toml_config = NamedTemporaryFile(          content=\"\"\"  [TAIPY]    [CORE]  mode = \"production\"  version_number = \"test_num_2\"  force = \"true:bool\"          \"\"\"      )      Config.load(toml_config.filename)      with patch(\"sys.argv\", [\"prog\"]):          core = Core()          core.run()      assert Config.core.mode == \"production\"      assert Config.core.version_number == \"test_num_2\"      assert Config.core.force      core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"test_num_3\", \"--no-taipy-force\"]):          core = Core()          core.run()          assert Config.core.mode == \"experiment\"          assert Config.core.version_number == \"test_num_3\"          assert not Config.core.force          core.stop()      def test_clean_config():      core_config = Config.configure_core(mode=\"experiment\", version_number=\"test_num\", force=True)        assert Config.core is core_config        core_config._clean()        # Check if the instance before and after _clean() is the same      assert Config.core is core_config        assert core_config.mode == \"development\"      assert core_config.version_number == \"\"        assert core_config.force is False      assert core_config.properties == {} "}
{"text": "from unittest.mock import patch    import pytest    from src.taipy.core import Core  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.config import MigrationConfig  from taipy.config.config import Config      def mock_func():      pass      def test_check_if_entity_property_key_used_is_predefined(caplog):      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()      assert caplog.text == \"\"      core.stop()        caplog.clear()        Config.unique_sections[MigrationConfig.name]._properties[\"_entity_owner\"] = None      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          with pytest.raises(SystemExit):              core = Core()              core.run()          core.stop()      assert (          \"Properties of MigrationConfig `VERSION_MIGRATION` cannot have `_entity_owner` as its property.\" in caplog.text      )        caplog.clear()        Config.unique_sections[MigrationConfig.name]._properties[\"_entity_owner\"] = \"entity_owner\"      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          with pytest.raises(SystemExit):              core = Core()              core.run()          core.stop()      expected_error_message = (          \"Properties of MigrationConfig `VERSION_MIGRATION` cannot have `_entity_owner` as its property.\"          ' Current value of property `_entity_owner` is \"entity_owner\".'      )      assert expected_error_message in caplog.text      def test_check_valid_version(caplog):      data_nodes1 = Config.configure_data_node(\"data_nodes1\", \"pickle\")        Config.add_migration_function(\"2.0\", data_nodes1, mock_func)      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          with pytest.raises(SystemExit):              core = Core()              core.run()          core.stop()      assert \"The target version for a migration function must be a production version.\" in caplog.text        caplog.clear()      Config.unblock_update()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()      assert caplog.text == \"\"      core.stop()      def test_check_callable_function(caplog):      data_nodes1 = Config.configure_data_node(\"data_nodes1\", \"pickle\")      Config.add_migration_function(\"1.0\", data_nodes1, 1)      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          with pytest.raises(SystemExit):              core = Core()              core.run()          core.stop()      expected_error_message = (          \"The migration function of config `data_nodes1` from version 1.0 must be populated with\"          \" Callable value. Current value of property `migration_fcts` is 1.\"      )      assert expected_error_message in caplog.text        caplog.clear()      Config.unblock_update()        Config.add_migration_function(\"1.0\", data_nodes1, \"bar\")      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          with pytest.raises(SystemExit):              core = Core()              core.run()          core.stop()      expected_error_message = (          \"The migration function of config `data_nodes1` from version 1.0 must be populated with\"          ' Callable value. Current value of property `migration_fcts` is \"bar\".'      )      assert expected_error_message in caplog.text        caplog.clear()      Config.unblock_update()        Config.add_migration_function(\"1.0\", data_nodes1, mock_func)      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()          core.stop()      def test_check_migration_from_productions_to_productions_exist(caplog):      _VersionManager._set_production_version(\"1.0\", True)      _VersionManager._set_production_version(\"1.1\", True)      _VersionManager._set_production_version(\"1.2\", True)        with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()          core.stop()      assert 'There is no migration function from production version \"1.0\" to version \"1.1\".' in caplog.text      assert 'There is no migration function from production version \"1.1\" to version \"1.2\".' in caplog.text        caplog.clear()      Config.unblock_update()        Config.add_migration_function(\"1.2\", \"data_nodes1\", mock_func)      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()          core.stop()      assert 'There is no migration function from production version \"1.0\" to version \"1.1\".' in caplog.text "}
{"text": "import pytest    from taipy.config.checker.issue_collector import IssueCollector  from taipy.config.config import Config      class TestConfigIdChecker:      def test_check_standalone_mode(self, caplog):          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            Config.configure_data_node(id=\"foo\", storage_type=\"in_memory\")          Config.configure_scenario(id=\"bar\", task_configs=[], additional_data_node_configs=[])            Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            Config.configure_data_node(id=\"bar\", task_configs=[])          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1            expected_error_message = (              \"`bar` is used as the config_id of multiple configurations ['DATA_NODE', 'SCENARIO']\"              ' Current value of property `config_id` is \"bar\".'          )          assert expected_error_message in caplog.text            Config.configure_task(id=\"bar\", function=print)          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"`bar` is used as the config_id of multiple configurations ['DATA_NODE', 'TASK', 'SCENARIO']\"              ' Current value of property `config_id` is \"bar\".'          )          assert expected_error_message in caplog.text            Config.configure_task(id=\"foo\", function=print)          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 2          expected_error_message = (              \"`foo` is used as the config_id of multiple configurations ['DATA_NODE', 'TASK']\"              ' Current value of property `config_id` is \"foo\".'          )          assert expected_error_message in caplog.text "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import pytest    from src.taipy.core.config.job_config import JobConfig  from taipy.config.checker.issue_collector import IssueCollector  from taipy.config.config import Config      class TestJobConfigChecker:      def test_check_standalone_mode(self, caplog):          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            Config.configure_data_node(id=\"foo\", storage_type=\"in_memory\")            Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE, max_nb_of_workers=2)          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=1)          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1            Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"DataNode `foo`: In-memory storage type can ONLY be used in development mode. Current\"              ' value of property `storage_type` is \"in_memory\".'          )          assert expected_error_message in caplog.text "}
{"text": "from src.taipy.core.config.checkers._core_section_checker import _CoreSectionChecker  from src.taipy.core.config.core_section import CoreSection  from taipy.config import Config  from taipy.config.checker.issue_collector import IssueCollector      class TestCoreSectionChecker:        _CoreSectionChecker._ACCEPTED_REPOSITORY_TYPES.update([\"mock_repo_type\"])        def test_check_valid_repository(self):          Config.configure_core(repository_type=\"mock_repo_type\")          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.warnings) == 0            Config.configure_core(repository_type=\"filesystem\")          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.warnings) == 0            Config.configure_core(repository_type=\"sql\")          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.warnings) == 0        def test_check_repository_type_value_wrong_str(self):          Config.configure_core(repository_type=\"any\")          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.warnings) == 1          assert Config._collector.warnings[0].field == CoreSection._REPOSITORY_TYPE_KEY          assert Config._collector.warnings[0].value == \"any\"        def test_check_repository_type_value_wrong_type(self):          Config.configure_core(repository_type=1)          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.warnings) == 1          assert Config._collector.warnings[0].field == CoreSection._REPOSITORY_TYPE_KEY          assert Config._collector.warnings[0].value == 1 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from queue import SimpleQueue    from src.taipy.core import taipy as tp  from src.taipy.core.notification.core_event_consumer import CoreEventConsumerBase  from src.taipy.core.notification.event import Event, EventEntityType, EventOperation  from src.taipy.core.notification.notifier import Notifier  from taipy.config import Config, Frequency  from tests.core.utils import assert_true_after_time      class AllCoreEventConsumerProcessor(CoreEventConsumerBase):      def __init__(self, registration_id: str, queue: SimpleQueue):          self.event_collected = 0          self.event_entity_type_collected: dict = {}          self.event_operation_collected: dict = {}          super().__init__(registration_id, queue)        def process_event(self, event: Event):          self.event_collected += 1          self.event_entity_type_collected[event.entity_type] = (              self.event_entity_type_collected.get(event.entity_type, 0) + 1          )          self.event_operation_collected[event.operation] = self.event_operation_collected.get(event.operation, 0) + 1      class ScenarioCoreEventConsumerProcessor(CoreEventConsumerBase):      def __init__(self, registration_id: str, queue: SimpleQueue):          self.scenario_event_collected = 0          self.event_operation_collected: dict = {}          super().__init__(registration_id, queue)        def process_event(self, event: Event):          self.scenario_event_collected += 1          self.event_operation_collected[event.operation] = self.event_operation_collected.get(event.operation, 0) + 1      class TaskCreationCoreEventConsumerProcessor(CoreEventConsumerBase):      def __init__(self, registration_id: str, queue: SimpleQueue):          self.task_event_collected = 0          self.creation_event_operation_collected = 0          super().__init__(registration_id, queue)        def process_event(self, event: Event):          self.task_event_collected += 1          self.creation_event_operation_collected += 1      def test_core_event_consumer():      register_id_0, register_queue_0 = Notifier.register()      all_evt_csumer_0 = AllCoreEventConsumerProcessor(register_id_0, register_queue_0)        register_id_1, register_queue_1 = Notifier.register(entity_type=EventEntityType.SCENARIO)      sc_evt_csumer_1 = ScenarioCoreEventConsumerProcessor(register_id_1, register_queue_1)        register_id_2, register_queue_2 = Notifier.register(          entity_type=EventEntityType.TASK, operation=EventOperation.CREATION      )      task_creation_evt_csumer_2 = TaskCreationCoreEventConsumerProcessor(register_id_2, register_queue_2)        all_evt_csumer_0.start()      sc_evt_csumer_1.start()      task_creation_evt_csumer_2.start()        dn_config = Config.configure_data_node(\"dn_config\")      task_config = Config.configure_task(\"task_config\", print, [dn_config])      scenario_config = Config.configure_scenario(          \"scenario_config\", [task_config], frequency=Frequency.DAILY, sequences={\"seq\": [task_config]}      )        # Create a scenario trigger 5 creation events      scenario = tp.create_scenario(scenario_config)      assert_true_after_time(lambda: all_evt_csumer_0.event_collected == 5, time=10)      assert_true_after_time(lambda: len(all_evt_csumer_0.event_entity_type_collected) == 5, time=10)      assert_true_after_time(lambda: all_evt_csumer_0.event_operation_collected[EventOperation.CREATION] == 5, time=10)      assert_true_after_time(lambda: sc_evt_csumer_1.scenario_event_collected == 1, time=10)      assert_true_after_time(lambda: sc_evt_csumer_1.event_operation_collected[EventOperation.CREATION] == 1, time=10)      assert_true_after_time(lambda: len(sc_evt_csumer_1.event_operation_collected) == 1, time=10)      assert_true_after_time(lambda: task_creation_evt_csumer_2.task_event_collected == 1, time=10)      assert_true_after_time(lambda: task_creation_evt_csumer_2.creation_event_operation_collected == 1, time=10)        # Delete a scenario trigger 5 update events      tp.delete(scenario.id)      assert_true_after_time(lambda: all_evt_csumer_0.event_collected == 10, time=10)      assert_true_after_time(lambda: len(all_evt_csumer_0.event_entity_type_collected) == 5, time=10)      assert_true_after_time(lambda: all_evt_csumer_0.event_operation_collected[EventOperation.DELETION] == 5, time=10)      assert_true_after_time(lambda: sc_evt_csumer_1.scenario_event_collected == 2, time=10)      assert_true_after_time(lambda: sc_evt_csumer_1.event_operation_collected[EventOperation.DELETION] == 1, time=10)      assert_true_after_time(lambda: len(sc_evt_csumer_1.event_operation_collected) == 2, time=10)      assert_true_after_time(lambda: task_creation_evt_csumer_2.task_event_collected == 1, time=10)      assert_true_after_time(lambda: task_creation_evt_csumer_2.creation_event_operation_collected == 1, time=10)        all_evt_csumer_0.stop()      sc_evt_csumer_1.stop()      task_creation_evt_csumer_2.stop() "}
{"text": "  from queue import SimpleQueue    from src.taipy.core.notification import EventEntityType, EventOperation  from src.taipy.core.notification._registration import _Registration  from src.taipy.core.notification._topic import _Topic      def test_create_registration():      registration_0 = _Registration()      assert isinstance(registration_0.registration_id, str)      assert registration_0.registration_id.startswith(_Registration._ID_PREFIX)      assert isinstance(registration_0.queue, SimpleQueue)      assert registration_0.queue.qsize() == 0      assert isinstance(registration_0.topic, _Topic)      assert registration_0.topic.entity_type is None      assert registration_0.topic.entity_id is None      assert registration_0.topic.operation is None      assert registration_0.topic.attribute_name is None        registration_1 = _Registration(          entity_type=EventEntityType.SCENARIO, entity_id=\"SCENARIO_scenario_id\", operation=EventOperation.CREATION      )      assert isinstance(registration_1.registration_id, str)      assert registration_1.registration_id.startswith(_Registration._ID_PREFIX)      assert isinstance(registration_1.queue, SimpleQueue)      assert registration_1.queue.qsize() == 0      assert isinstance(registration_1.topic, _Topic)      assert registration_1.topic.entity_type == EventEntityType.SCENARIO      assert registration_1.topic.entity_id == \"SCENARIO_scenario_id\"      assert registration_1.topic.operation == EventOperation.CREATION      assert registration_1.topic.attribute_name is None        registration_2 = _Registration(          entity_type=EventEntityType.SEQUENCE,          entity_id=\"SEQUENCE_scenario_id\",          operation=EventOperation.UPDATE,          attribute_name=\"tasks\",      )      assert isinstance(registration_2.registration_id, str)      assert registration_2.registration_id.startswith(_Registration._ID_PREFIX)      assert isinstance(registration_2.queue, SimpleQueue)      assert registration_2.queue.qsize() == 0      assert isinstance(registration_2.topic, _Topic)      assert registration_2.topic.entity_type == EventEntityType.SEQUENCE      assert registration_2.topic.entity_id == \"SEQUENCE_scenario_id\"      assert registration_2.topic.operation == EventOperation.UPDATE      assert registration_2.topic.attribute_name == \"tasks\" "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import os    import pytest    from src.taipy.core.cycle._cycle_fs_repository import _CycleFSRepository  from src.taipy.core.cycle._cycle_sql_repository import _CycleSQLRepository  from src.taipy.core.cycle.cycle import Cycle, CycleId  from src.taipy.core.exceptions import ModelNotFound      class TestCycleRepositories:      @pytest.mark.parametrize(\"repo\", [_CycleFSRepository, _CycleSQLRepository])      def test_save_and_load(self, cycle, repo, init_sql_repo):          repository = repo()          repository._save(cycle)            obj = repository._load(cycle.id)          assert isinstance(obj, Cycle)        @pytest.mark.parametrize(\"repo\", [_CycleFSRepository, _CycleSQLRepository])      def test_exists(self, cycle, repo, init_sql_repo):          repository = repo()          repository._save(cycle)            assert repository._exists(cycle.id)          assert not repository._exists(\"not-existed-cycle\")        @pytest.mark.parametrize(\"repo\", [_CycleFSRepository, _CycleSQLRepository])      def test_load_all(self, cycle, repo, init_sql_repo):          repository = repo()          for i in range(10):              cycle.id = CycleId(f\"cycle-{i}\")              repository._save(cycle)          data_nodes = repository._load_all()            assert len(data_nodes) == 10        @pytest.mark.parametrize(\"repo\", [_CycleFSRepository, _CycleSQLRepository])      def test_load_all_with_filters(self, cycle, repo, init_sql_repo):          repository = repo()            for i in range(10):              cycle.id = CycleId(f\"cycle-{i}\")              cycle._name = f\"cycle-{i}\"              repository._save(cycle)          objs = repository._load_all(filters=[{\"id\": \"cycle-2\"}])            assert len(objs) == 1        @pytest.mark.parametrize(\"repo\", [_CycleSQLRepository])      def test_delete(self, cycle, repo, init_sql_repo):          repository = repo()          repository._save(cycle)            repository._delete(cycle.id)            with pytest.raises(ModelNotFound):              repository._load(cycle.id)        @pytest.mark.parametrize(\"repo\", [_CycleFSRepository, _CycleSQLRepository])      def test_delete_all(self, cycle, repo, init_sql_repo):          repository = repo()            for i in range(10):              cycle.id = CycleId(f\"cycle-{i}\")              repository._save(cycle)            assert len(repository._load_all()) == 10            repository._delete_all()            assert len(repository._load_all()) == 0        @pytest.mark.parametrize(\"repo\", [_CycleFSRepository, _CycleSQLRepository])      def test_delete_many(self, cycle, repo, init_sql_repo):          repository = repo()            for i in range(10):              cycle.id = CycleId(f\"cycle-{i}\")              repository._save(cycle)            objs = repository._load_all()          assert len(objs) == 10          ids = [x.id for x in objs[:3]]          repository._delete_many(ids)            assert len(repository._load_all()) == 7        @pytest.mark.parametrize(\"repo\", [_CycleFSRepository, _CycleSQLRepository])      def test_search(self, cycle, repo, init_sql_repo):          repository = repo()            for i in range(10):              cycle.id = CycleId(f\"cycle-{i}\")              cycle.name = f\"cycle-{i}\"              repository._save(cycle)            assert len(repository._load_all()) == 10            objs = repository._search(\"name\", \"cycle-2\")          assert len(objs) == 1          assert isinstance(objs[0], Cycle)        @pytest.mark.parametrize(\"repo\", [_CycleFSRepository, _CycleSQLRepository])      def test_export(self, tmpdir, cycle, repo, init_sql_repo):          repository = repo()          repository._save(cycle)            repository._export(cycle.id, tmpdir.strpath)          dir_path = repository.dir_path if repo == _CycleFSRepository else os.path.join(tmpdir.strpath, \"cycle\")          assert os.path.exists(os.path.join(dir_path, f\"{cycle.id}.json\")) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import dataclasses  import pathlib  from dataclasses import dataclass  from typing import Any, Dict, Iterable, List, Optional, Union    from src.taipy.core._manager._manager import _Manager  from src.taipy.core._repository._abstract_converter import _AbstractConverter  from src.taipy.core._repository._abstract_repository import _AbstractRepository  from src.taipy.core._repository._filesystem_repository import _FileSystemRepository  from src.taipy.core._version._version_manager import _VersionManager  from taipy.config.config import Config      @dataclass  class MockModel:      id: str      name: str      version: str        def to_dict(self):          return dataclasses.asdict(self)        @staticmethod      def from_dict(data: Dict[str, Any]):          return MockModel(id=data[\"id\"], name=data[\"name\"], version=data[\"version\"])      @dataclass  class MockEntity:      def __init__(self, id: str, name: str, version: str = None) -> None:          self.id = id          self.name = name          if version:              self._version = version          else:              self._version = _VersionManager._get_latest_version()      class MockConverter(_AbstractConverter):      @classmethod      def _entity_to_model(cls, entity: MockEntity) -> MockModel:          return MockModel(id=entity.id, name=entity.name, version=entity._version)        @classmethod      def _model_to_entity(cls, model: MockModel) -> MockEntity:          return MockEntity(id=model.id, name=model.name, version=model.version)      class MockRepository(_AbstractRepository):  # type: ignore      def __init__(self, **kwargs):          self.repo = _FileSystemRepository(**kwargs, converter=MockConverter)        def _to_model(self, obj: MockEntity):          return MockModel(obj.id, obj.name, obj._version)        def _from_model(self, model: MockModel):          return MockEntity(model.id, model.name, model.version)        def _load(self, entity_id: str) -> MockEntity:          return self.repo._load(entity_id)        def _load_all(self, filters: Optional[List[Dict]] = None) -> List[MockEntity]:          return self.repo._load_all(filters)        def _save(self, entity: MockEntity):          return self.repo._save(entity)        def _exists(self, entity_id: str) -> bool:          return self.repo._exists(entity_id)        def _delete(self, entity_id: str):          return self.repo._delete(entity_id)        def _delete_all(self):          return self.repo._delete_all()        def _delete_many(self, ids: Iterable[str]):          return self.repo._delete_many(ids)        def _delete_by(self, attribute: str, value: str):          return self.repo._delete_by(attribute, value)        def _search(self, attribute: str, value: Any, filters: Optional[List[Dict]] = None) -> List[MockEntity]:          return self.repo._search(attribute, value, filters)        def _export(self, entity_id: str, folder_path: Union[str, pathlib.Path]):          return self.repo._export(self, entity_id, folder_path)        @property      def _storage_folder(self) -> pathlib.Path:          return pathlib.Path(Config.core.storage_folder)  # type: ignore      class MockManager(_Manager[MockEntity]):      _ENTITY_NAME = MockEntity.__name__      _repository = MockRepository(model_type=MockModel, dir_name=\"foo\")      class TestManager:      def test_save_and_fetch_model(self):          m = MockEntity(\"uuid\", \"foo\")          MockManager._set(m)            fetched_model = MockManager._get(m.id)          assert m == fetched_model        def test_exists(self):          m = MockEntity(\"uuid\", \"foo\")          MockManager._set(m)          assert MockManager._exists(m.id)        def test_get(self):          m = MockEntity(\"uuid\", \"foo\")          MockManager._set(m)          assert MockManager._get(m.id) == m        def test_get_all(self):          MockManager._delete_all()            objs = []          for i in range(5):              m = MockEntity(f\"uuid-{i}\", f\"Foo{i}\")              objs.append(m)              MockManager._set(m)          _objs = MockManager._get_all()            assert len(_objs) == 5        def test_delete(self):          m = MockEntity(\"uuid\", \"foo\")          MockManager._set(m)          MockManager._delete(m.id)          assert MockManager._get(m.id) is None        def test_delete_all(self):          objs = []          for i in range(5):              m = MockEntity(f\"uuid-{i}\", f\"Foo{i}\")              objs.append(m)              MockManager._set(m)          MockManager._delete_all()          assert MockManager._get_all() == []        def test_delete_many(self):          objs = []          for i in range(5):              m = MockEntity(f\"uuid-{i}\", f\"Foo{i}\")              objs.append(m)              MockManager._set(m)          MockManager._delete_many([\"uuid-0\", \"uuid-1\"])          assert len(MockManager._get_all()) == 3        def test_is_editable(self):          m = MockEntity(\"uuid\", \"Foo\")          MockManager._set(m)          assert MockManager._is_editable(m)        def test_is_readable(self):          m = MockEntity(\"uuid\", \"Foo\")          MockManager._set(m)          assert MockManager._is_readable(m) "}
{"text": "  class NotifyMock:      \"\"\"      A shared class for testing notification on jobStatus of sequence level and scenario level        \"entity\" can be understood as either \"scenario\" or \"sequence\".      \"\"\"        def __init__(self, entity):          self.scenario = entity          self.nb_called = 0          self.__name__ = \"NotifyMock\"        def __call__(self, entity, job):          assert entity == self.scenario          if self.nb_called == 0:              assert job.is_pending()          if self.nb_called == 1:              assert job.is_running()          if self.nb_called == 2:              assert job.is_finished()          self.nb_called += 1        def assert_called_3_times(self):          assert self.nb_called == 3        def assert_not_called(self):          assert self.nb_called == 0        def reset(self):          self.nb_called = 0 "}
{"text": "  def assert_true_after_time(assertion, msg=None, time=120):      from datetime import datetime      from time import sleep        loops = 0      start = datetime.now()      while (datetime.now() - start).seconds < time:          sleep(1)  # Limit CPU usage          try:              if assertion():                  return          except BaseException as e:              print(\"Raise : \", e)              loops += 1              continue      if msg:          print(msg)      assert assertion() "}
{"text": "import os  import tempfile      class NamedTemporaryFile:      def __init__(self, content=None):          with tempfile.NamedTemporaryFile(\"w\", delete=False) as fd:              if content:                  fd.write(content)              self.filename = fd.name        def read(self):          with open(self.filename, \"r\") as fp:              return fp.read()        def __del__(self):          os.unlink(self.filename) "}
{"text": "from unittest import mock    import pytest    from src.taipy.core import taipy  from src.taipy.core._entity._labeled import _Labeled  from taipy.config import Config, Frequency, Scope      class MockOwner:      label = \"owner_label\"        def get_label(self):          return self.label      def test_get_label():      labeled_entity = _Labeled()        with pytest.raises(NotImplementedError):          labeled_entity.get_label()        with pytest.raises(NotImplementedError):          labeled_entity.get_simple_label()        with pytest.raises(AttributeError):          labeled_entity._get_label()        with pytest.raises(AttributeError):          labeled_entity._get_simple_label()        labeled_entity.id = \"id\"      assert labeled_entity._get_label() == \"id\"      assert labeled_entity._get_simple_label() == \"id\"        labeled_entity.config_id = \"the config id\"      assert labeled_entity._get_label() == \"the config id\"      assert labeled_entity._get_simple_label() == \"the config id\"        labeled_entity._properties = {\"name\": \"a name\"}      assert labeled_entity._get_label() == \"a name\"      assert labeled_entity._get_simple_label() == \"a name\"        labeled_entity.owner_id = \"owner_id\"      with mock.patch(\"src.taipy.core.get\") as get_mck:          get_mck.return_value = MockOwner()          assert labeled_entity._get_label() == \"owner_label > a name\"          assert labeled_entity._get_simple_label() == \"a name\"            labeled_entity._properties[\"label\"] = \"a wonderful label\"          assert labeled_entity._get_label() == \"a wonderful label\"          assert labeled_entity._get_simple_label() == \"a wonderful label\"      def mult(n1, n2):      return n1 * n2      def test_get_label_complex_case():        dn1_cfg = Config.configure_data_node(\"dn1\", scope=Scope.GLOBAL)      dn2_cfg = Config.configure_data_node(\"dn2\", scope=Scope.CYCLE)      dn3_cfg = Config.configure_data_node(\"dn3\", scope=Scope.CYCLE)      dn4_cfg = Config.configure_data_node(\"dn4\", scope=Scope.SCENARIO)      dn5_cfg = Config.configure_data_node(\"dn5\", scope=Scope.SCENARIO)      tA_cfg = Config.configure_task(\"t_A_C\", mult, [dn1_cfg, dn2_cfg], dn3_cfg)      tB_cfg = Config.configure_task(\"t_B_S\", mult, [dn3_cfg, dn4_cfg], dn5_cfg)      scenario_cfg = Config.configure_scenario(\"scenario_cfg\", [tA_cfg, tB_cfg], [], Frequency.DAILY)      scenario_cfg.add_sequences(          {              \"sequence_C\": [tA_cfg],              \"sequence_S\": [tA_cfg, tB_cfg],          }      )        scenario = taipy.create_scenario(scenario_cfg, name=\"My Name\")      cycle = scenario.cycle      cycle.name = \"Today\"      sequence_C = scenario.sequence_C      sequence_S = scenario.sequence_S      tA = scenario.t_A_C      tB = scenario.t_B_S      dn1 = scenario.dn1      dn2 = scenario.dn2      dn3 = scenario.dn3      dn4 = scenario.dn4      dn5 = scenario.dn5        assert cycle.get_label() == scenario.cycle.name      assert cycle.get_simple_label() == scenario.cycle.name      assert scenario.get_label() == \"Today > My Name\"      assert scenario.get_simple_label() == \"My Name\"      assert sequence_C.get_label() == \"Today > My Name > sequence_C\"      assert sequence_C.get_simple_label() == \"sequence_C\"      assert sequence_S.get_label() == \"Today > My Name > sequence_S\"      assert sequence_S.get_simple_label() == \"sequence_S\"      assert tA.get_label() == \"Today > t_A_C\"      assert tA.get_simple_label() == \"t_A_C\"      assert tB.get_label() == \"Today > My Name > t_B_S\"      assert tB.get_simple_label() == \"t_B_S\"      assert dn1.get_label() == \"dn1\"      assert dn1.get_simple_label() == \"dn1\"      assert dn2.get_label() == \"Today > dn2\"      assert dn2.get_simple_label() == \"dn2\"      assert dn3.get_label() == \"Today > dn3\"      assert dn3.get_simple_label() == \"dn3\"      assert dn4.get_label() == \"Today > My Name > dn4\"      assert dn4.get_simple_label() == \"dn4\"      assert dn5.get_label() == \"Today > My Name > dn5\"      assert dn5.get_simple_label() == \"dn5\" "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from src.taipy.core._entity._entity_ids import _EntityIds      class TestEntityIds:      def test_add_two_entity_ids(self):          entity_ids_1 = _EntityIds()          entity_ids_2 = _EntityIds()            entity_ids_1_address = id(entity_ids_1)            entity_ids_1.data_node_ids.update([\"data_node_id_1\", \"data_node_id_2\"])          entity_ids_1.task_ids.update([\"task_id_1\", \"task_id_2\"])          entity_ids_1.job_ids.update([\"job_id_1\", \"job_id_2\"])          entity_ids_1.sequence_ids.update([\"sequence_id_1\", \"sequence_id_2\"])          entity_ids_1.scenario_ids.update([\"scenario_id_1\", \"scenario_id_2\"])          entity_ids_1.cycle_ids.update([\"cycle_id_1\", \"cycle_id_2\"])            entity_ids_2.data_node_ids.update([\"data_node_id_2\", \"data_node_id_3\"])          entity_ids_2.task_ids.update([\"task_id_2\", \"task_id_3\"])          entity_ids_2.job_ids.update([\"job_id_2\", \"job_id_3\"])          entity_ids_2.sequence_ids.update([\"sequence_id_2\", \"sequence_id_3\"])          entity_ids_2.scenario_ids.update([\"scenario_id_2\", \"scenario_id_3\"])          entity_ids_2.cycle_ids.update([\"cycle_id_2\", \"cycle_id_3\"])            entity_ids_1 += entity_ids_2            # += operator should not change the address of entity_ids_1          assert id(entity_ids_1) == entity_ids_1_address            assert entity_ids_1.data_node_ids == {\"data_node_id_1\", \"data_node_id_2\", \"data_node_id_3\"}          assert entity_ids_1.task_ids == {\"task_id_1\", \"task_id_2\", \"task_id_3\"}          assert entity_ids_1.job_ids == {\"job_id_1\", \"job_id_2\", \"job_id_3\"}          assert entity_ids_1.sequence_ids == {\"sequence_id_1\", \"sequence_id_2\", \"sequence_id_3\"}          assert entity_ids_1.scenario_ids == {\"scenario_id_1\", \"scenario_id_2\", \"scenario_id_3\"}          assert entity_ids_1.cycle_ids == {\"cycle_id_1\", \"cycle_id_2\", \"cycle_id_3\"} "}
{"text": "import pytest    from src.taipy.core.common._utils import _retry_read_entity  from taipy.config import Config      def test_retry_decorator(mocker):      func = mocker.Mock(side_effect=Exception())        @_retry_read_entity((Exception,))      def decorated_func():          func()        with pytest.raises(Exception):          decorated_func()      # Called once in the normal flow and no retry      # The Config.core.read_entity_retry is set to 0 at conftest.py      assert Config.core.read_entity_retry == 0      assert func.call_count == 1        func.reset_mock()        Config.core.read_entity_retry = 3      with pytest.raises(Exception):          decorated_func()      # Called once in the normal flow and 3 more times on the retry flow      assert func.call_count == 4      def test_retry_decorator_exception_not_in_list(mocker):      func = mocker.Mock(side_effect=KeyError())      Config.core.read_entity_retry = 3        @_retry_read_entity((Exception,))      def decorated_func():          func()        with pytest.raises(KeyError):          decorated_func()      # Called only on the first time and not trigger retry because KeyError is not on the exceptions list      assert func.called == 1 "}
{"text": "from src.taipy.core.common.warn_if_inputs_not_ready import _warn_if_inputs_not_ready  from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from taipy.config import Config      def test_warn_inputs_all_not_ready(caplog):      one = Config.configure_data_node(\"one\")      two = Config.configure_data_node(\"two\")      three = Config.configure_data_node(\"three\")      data_nodes = _DataManagerFactory._build_manager()._bulk_get_or_create({one, two, three}).values()        _warn_if_inputs_not_ready(data_nodes)        stdout = caplog.text      expected_outputs = [          f\"{input_dn.id} cannot be read because it has never been written. Hint: The data node may refer to a wrong \"          f\"path : {input_dn.path} \"          for input_dn in data_nodes      ]      assert all([expected_output in stdout for expected_output in expected_outputs])      def test_warn_inputs_all_ready(caplog):      one = Config.configure_data_node(\"one\", default_data=1)      two = Config.configure_data_node(\"two\", default_data=2)      three = Config.configure_data_node(\"three\", default_data=3)      data_nodes = _DataManagerFactory._build_manager()._bulk_get_or_create({one, two, three}).values()        _warn_if_inputs_not_ready(data_nodes)        stdout = caplog.text      not_expected_outputs = [          f\"{input_dn.id} cannot be read because it has never been written. Hint: The data node may refer to a wrong \"          f\"path : {input_dn.path} \"          for input_dn in data_nodes      ]      assert all([expected_output not in stdout for expected_output in not_expected_outputs])      def test_warn_inputs_one_ready(caplog):      one = Config.configure_data_node(\"one\", default_data=1)      two = Config.configure_data_node(\"two\")      three = Config.configure_data_node(\"three\")      data_nodes = _DataManagerFactory._build_manager()._bulk_get_or_create({one, two, three})        _warn_if_inputs_not_ready(data_nodes.values())        stdout = caplog.text      expected_outputs = [          f\"{input_dn.id} cannot be read because it has never been written. Hint: The data node may refer to a wrong \"          f\"path : {input_dn.path} \"          for input_dn in [data_nodes[two], data_nodes[three]]      ]        not_expected_outputs = [          f\"{input_dn.id} cannot be read because it has never been written. Hint: The data node may refer to a wrong \"          f\"path : {input_dn.path} \"          for input_dn in [data_nodes[one]]      ]        assert all([expected_output in stdout for expected_output in expected_outputs])      assert all([expected_output not in stdout for expected_output in not_expected_outputs])      def test_submit_task_with_input_dn_wrong_file_path(caplog):      csv_dn_cfg = Config.configure_csv_data_node(\"wrong_csv_file_path\", default_path=\"wrong_path.csv\")      excel_dn_cfg = Config.configure_excel_data_node(\"wrong_excel_file_path\", default_path=\"wrong_path.xlsx\")      json_dn_cfg = Config.configure_json_data_node(\"wrong_json_file_path\", default_path=\"wrong_path.json\")      pickle_dn_cfg = Config.configure_pickle_data_node(\"wrong_pickle_file_path\", default_path=\"wrong_path.pickle\")      parquet_dn_cfg = Config.configure_parquet_data_node(\"wrong_parquet_file_path\", default_path=\"wrong_path.parquet\")      input_dn_cfgs = [csv_dn_cfg, excel_dn_cfg, json_dn_cfg, pickle_dn_cfg, parquet_dn_cfg]        dn_manager = _DataManagerFactory._build_manager()      dns = [dn_manager._bulk_get_or_create([input_dn_cfg])[input_dn_cfg] for input_dn_cfg in input_dn_cfgs]        _warn_if_inputs_not_ready(dns)        stdout = caplog.text      expected_outputs = [          f\"{input_dn.id} cannot be read because it has never been written. Hint: The data node may refer to a wrong \"          f\"path : {input_dn.path} \"          for input_dn in dns      ]      assert all([expected_output in stdout for expected_output in expected_outputs]) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import os    import pytest    from src.taipy.core.exceptions import ModelNotFound  from src.taipy.core.scenario._scenario_fs_repository import _ScenarioFSRepository  from src.taipy.core.scenario._scenario_sql_repository import _ScenarioSQLRepository  from src.taipy.core.scenario.scenario import Scenario, ScenarioId      class TestScenarioFSRepository:      @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_save_and_load(self, scenario, repo, init_sql_repo):          repository = repo()          repository._save(scenario)            obj = repository._load(scenario.id)          assert isinstance(obj, Scenario)        @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_exists(self, scenario, repo, init_sql_repo):          repository = repo()          repository._save(scenario)            assert repository._exists(scenario.id)          assert not repository._exists(\"not-existed-scenario\")        @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_load_all(self, scenario, repo, init_sql_repo):          repository = repo()          for i in range(10):              scenario.id = ScenarioId(f\"scenario-{i}\")              repository._save(scenario)          data_nodes = repository._load_all()            assert len(data_nodes) == 10        @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_load_all_with_filters(self, scenario, repo, init_sql_repo):          repository = repo()            for i in range(10):              scenario.id = ScenarioId(f\"scenario-{i}\")              repository._save(scenario)          objs = repository._load_all(filters=[{\"id\": \"scenario-2\"}])            assert len(objs) == 1        @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_delete(self, scenario, repo, init_sql_repo):          repository = repo()          repository._save(scenario)            repository._delete(scenario.id)            with pytest.raises(ModelNotFound):              repository._load(scenario.id)        @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_delete_all(self, scenario, repo, init_sql_repo):          repository = repo()            for i in range(10):              scenario.id = ScenarioId(f\"scenario-{i}\")              repository._save(scenario)            assert len(repository._load_all()) == 10            repository._delete_all()            assert len(repository._load_all()) == 0        @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_delete_many(self, scenario, repo, init_sql_repo):          repository = repo()            for i in range(10):              scenario.id = ScenarioId(f\"scenario-{i}\")              repository._save(scenario)            objs = repository._load_all()          assert len(objs) == 10          ids = [x.id for x in objs[:3]]          repository._delete_many(ids)            assert len(repository._load_all()) == 7        @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_delete_by(self, scenario, repo, init_sql_repo):          repository = repo()            # Create 5 entities with version 1.0 and 5 entities with version 2.0          for i in range(10):              scenario.id = ScenarioId(f\"scenario-{i}\")              scenario._version = f\"{(i+1) // 5}.0\"              repository._save(scenario)            objs = repository._load_all()          assert len(objs) == 10          repository._delete_by(\"version\", \"1.0\")            assert len(repository._load_all()) == 5        @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_search(self, scenario, repo, init_sql_repo):          repository = repo()            for i in range(10):              scenario.id = ScenarioId(f\"scenario-{i}\")              repository._save(scenario)            assert len(repository._load_all()) == 10            objs = repository._search(\"id\", \"scenario-2\")          assert len(objs) == 1          assert isinstance(objs[0], Scenario)            objs = repository._search(\"id\", \"scenario-2\", filters=[{\"version\": \"random_version_number\"}])          assert len(objs) == 1          assert isinstance(objs[0], Scenario)            assert repository._search(\"id\", \"scenario-2\", filters=[{\"version\": \"non_existed_version\"}]) == []        @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_export(self, tmpdir, scenario, repo, init_sql_repo):          repository = repo()          repository._save(scenario)            repository._export(scenario.id, tmpdir.strpath)          dir_path = repository.dir_path if repo == _ScenarioFSRepository else os.path.join(tmpdir.strpath, \"scenario\")            assert os.path.exists(os.path.join(dir_path, f\"{scenario.id}.json\")) "}
{"text": "from src.taipy.core._version._version import _Version  from taipy.config.config import Config      def test_create_version():      v = _Version(\"foo\", config=Config.configure_data_node(\"dn\"))      assert v.id == \"foo\"      assert v.config is not None "}
{"text": "import os    import pytest    from src.taipy.core._version._version import _Version  from src.taipy.core._version._version_fs_repository import _VersionFSRepository  from src.taipy.core._version._version_sql_repository import _VersionSQLRepository  from src.taipy.core.exceptions import ModelNotFound      class TestVersionFSRepository:      @pytest.mark.parametrize(\"repo\", [_VersionFSRepository, _VersionSQLRepository])      def test_save_and_load(self, _version, repo, init_sql_repo):          repository = repo()          repository._save(_version)            obj = repository._load(_version.id)          assert isinstance(obj, _Version)        @pytest.mark.parametrize(\"repo\", [_VersionFSRepository, _VersionSQLRepository])      def test_exists(self, _version, repo, init_sql_repo):          repository = repo()          repository._save(_version)            assert repository._exists(_version.id)          assert not repository._exists(\"not-existed-version\")        @pytest.mark.parametrize(\"repo\", [_VersionFSRepository, _VersionSQLRepository])      def test_load_all(self, _version, repo, init_sql_repo):          repository = repo()          for i in range(10):              _version.id = f\"_version_{i}\"              repository._save(_version)          data_nodes = repository._load_all()            assert len(data_nodes) == 10        @pytest.mark.parametrize(\"repo\", [_VersionFSRepository, _VersionSQLRepository])      def test_load_all_with_filters(self, _version, repo, init_sql_repo):          repository = repo()            for i in range(10):              _version.id = f\"_version_{i}\"              _version.name = f\"_version_{i}\"              repository._save(_version)          objs = repository._load_all(filters=[{\"id\": \"_version_2\"}])            assert len(objs) == 1        @pytest.mark.parametrize(\"repo\", [_VersionFSRepository, _VersionSQLRepository])      def test_delete(self, _version, repo, init_sql_repo):          repository = repo()          repository._save(_version)            repository._delete(_version.id)            with pytest.raises(ModelNotFound):              repository._load(_version.id)        @pytest.mark.parametrize(\"repo\", [_VersionFSRepository, _VersionSQLRepository])      def test_delete_all(self, _version, repo, init_sql_repo):          repository = repo()            for i in range(10):              _version.id = f\"_version_{i}\"              repository._save(_version)            assert len(repository._load_all()) == 10            repository._delete_all()            assert len(repository._load_all()) == 0        @pytest.mark.parametrize(\"repo\", [_VersionFSRepository, _VersionSQLRepository])      def test_delete_many(self, _version, repo, init_sql_repo):          repository = repo()            for i in range(10):              _version.id = f\"_version_{i}\"              repository._save(_version)            objs = repository._load_all()          assert len(objs) == 10          ids = [x.id for x in objs[:3]]          repository._delete_many(ids)            assert len(repository._load_all()) == 7        @pytest.mark.parametrize(\"repo\", [_VersionFSRepository, _VersionSQLRepository])      def test_search(self, _version, repo, init_sql_repo):          repository = repo()            for i in range(10):              _version.id = f\"_version_{i}\"              _version.name = f\"_version_{i}\"              repository._save(_version)            assert len(repository._load_all()) == 10            objs = repository._search(\"id\", \"_version_2\")          assert len(objs) == 1          assert isinstance(objs[0], _Version)        @pytest.mark.parametrize(\"repo\", [_VersionFSRepository, _VersionSQLRepository])      def test_export(self, tmpdir, _version, repo, init_sql_repo):          repository = repo()          repository._save(_version)            repository._export(_version.id, tmpdir.strpath)          dir_path = repository.dir_path if repo == _VersionFSRepository else os.path.join(tmpdir.strpath, \"version\")            assert os.path.exists(os.path.join(dir_path, f\"{_version.id}.json\")) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import pytest    from src.taipy.core._version._version import _Version  from src.taipy.core._version._version_manager import _VersionManager  from taipy.config.config import Config      def test_save_and_get_version_entity(tmpdir):      _VersionManager._repository.base_path = tmpdir      assert len(_VersionManager._get_all()) == 0        version = _Version(id=\"foo\", config=Config._applied_config)        _VersionManager._get_or_create(id=\"foo\", force=False)        version_1 = _VersionManager._get(version.id)      assert version_1.id == version.id      assert Config._serializer._str(version_1.config) == Config._serializer._str(version.config)        assert len(_VersionManager._get_all()) == 1      assert _VersionManager._get(version.id) == version "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from unittest import mock    import pytest    from src.taipy.core._orchestrator._dispatcher import _DevelopmentJobDispatcher, _JobDispatcher, _StandaloneJobDispatcher  from src.taipy.core._orchestrator._orchestrator import _Orchestrator  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.exceptions.exceptions import OrchestratorNotBuilt  from taipy.config import Config      def test_build_orchestrator():      _OrchestratorFactory._orchestrator = None      _OrchestratorFactory._dispatcher = None        assert _OrchestratorFactory._orchestrator is None      assert _OrchestratorFactory._dispatcher is None        orchestrator = _OrchestratorFactory._build_orchestrator()      assert orchestrator == _Orchestrator      assert _OrchestratorFactory._orchestrator == _Orchestrator      dispatcher = _OrchestratorFactory._build_dispatcher()      assert isinstance(dispatcher, _JobDispatcher)      assert isinstance(_OrchestratorFactory._dispatcher, _JobDispatcher)        _OrchestratorFactory._orchestrator = None      assert _OrchestratorFactory._orchestrator is None      assert _OrchestratorFactory._dispatcher is not None        with mock.patch(          \"src.taipy.core._orchestrator._orchestrator_factory._OrchestratorFactory._build_dispatcher\"      ) as build_dispatcher, mock.patch(          \"src.taipy.core._orchestrator._orchestrator._Orchestrator.initialize\"      ) as initialize:          orchestrator = _OrchestratorFactory._build_orchestrator()          assert orchestrator == _Orchestrator          assert _OrchestratorFactory._orchestrator == _Orchestrator          build_dispatcher.assert_not_called()          initialize.assert_called_once()      def test_build_development_dispatcher():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._orchestrator = None      _OrchestratorFactory._dispatcher = None        assert _OrchestratorFactory._orchestrator is None      assert _OrchestratorFactory._dispatcher is None        with pytest.raises(OrchestratorNotBuilt):          _OrchestratorFactory._build_dispatcher()        _OrchestratorFactory._build_orchestrator()      assert _OrchestratorFactory._orchestrator is not None      assert _OrchestratorFactory._dispatcher is None        _OrchestratorFactory._build_dispatcher()      assert isinstance(_OrchestratorFactory._dispatcher, _DevelopmentJobDispatcher)      def test_build_standalone_dispatcher():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()      assert isinstance(_OrchestratorFactory._dispatcher, _StandaloneJobDispatcher)      assert not isinstance(_OrchestratorFactory._dispatcher, _DevelopmentJobDispatcher)      assert _OrchestratorFactory._dispatcher.is_running()      assert _OrchestratorFactory._dispatcher._nb_available_workers == 2      _OrchestratorFactory._dispatcher._nb_available_workers = 1        _OrchestratorFactory._build_dispatcher(force_restart=False)      assert _OrchestratorFactory._dispatcher.is_running()      assert _OrchestratorFactory._dispatcher._nb_available_workers == 1        _OrchestratorFactory._build_dispatcher(force_restart=True)      assert _OrchestratorFactory._dispatcher.is_running()      assert _OrchestratorFactory._dispatcher._nb_available_workers == 2 "}
{"text": "import multiprocessing  from concurrent.futures import ProcessPoolExecutor  from functools import partial  from unittest import mock  from unittest.mock import MagicMock    from pytest import raises    from src.taipy.core import DataNodeId, JobId, TaskId  from src.taipy.core._orchestrator._dispatcher._development_job_dispatcher import _DevelopmentJobDispatcher  from src.taipy.core._orchestrator._dispatcher._standalone_job_dispatcher import _StandaloneJobDispatcher  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.job.job import Job  from src.taipy.core.submission._submission_manager_factory import _SubmissionManagerFactory  from src.taipy.core.task.task import Task  from taipy.config.config import Config  from tests.core.utils import assert_true_after_time      def execute(lock):      with lock:          ...      return None      def _error():      raise RuntimeError(\"Something bad has happened\")      def test_build_development_job_dispatcher():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()      dispatcher = _OrchestratorFactory._dispatcher        assert isinstance(dispatcher, _DevelopmentJobDispatcher)      assert dispatcher._nb_available_workers == 1        with raises(NotImplementedError):          assert dispatcher.start()        assert dispatcher.is_running()        with raises(NotImplementedError):          dispatcher.stop()      def test_build_standalone_job_dispatcher():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()      dispatcher = _OrchestratorFactory._dispatcher        assert not isinstance(dispatcher, _DevelopmentJobDispatcher)      assert isinstance(dispatcher, _StandaloneJobDispatcher)      assert isinstance(dispatcher._executor, ProcessPoolExecutor)      assert dispatcher._nb_available_workers == 2      assert_true_after_time(dispatcher.is_running)      dispatcher.stop()      dispatcher.join()      assert_true_after_time(lambda: not dispatcher.is_running())      def test_can_execute_2_workers():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        m = multiprocessing.Manager()      lock = m.Lock()        task_id = TaskId(\"task_id1\")      output = list(_DataManager._bulk_get_or_create([Config.configure_data_node(\"input1\", default_data=21)]).values())        _OrchestratorFactory._build_dispatcher()        task = Task(          config_id=\"name\",          properties={},          input=[],          function=partial(execute, lock),          output=output,          id=task_id,      )      job_id = JobId(\"id1\")      job = Job(job_id, task, \"submit_id\", task.id)        dispatcher = _StandaloneJobDispatcher(_OrchestratorFactory._orchestrator)        with lock:          assert dispatcher._can_execute()          dispatcher._dispatch(job)          assert dispatcher._can_execute()          dispatcher._dispatch(job)          assert not dispatcher._can_execute()        assert_true_after_time(lambda: dispatcher._can_execute())      def test_can_execute_synchronous():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        task_id = TaskId(\"task_id1\")      task = Task(config_id=\"name\", properties={}, input=[], function=print, output=[], id=task_id)      submission = _SubmissionManagerFactory._build_manager()._create(task_id)      job_id = JobId(\"id1\")      job = Job(job_id, task, submission.id, task.id)        dispatcher = _OrchestratorFactory._dispatcher        assert dispatcher._can_execute()      dispatcher._dispatch(job)      assert dispatcher._can_execute()      def test_exception_in_user_function():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        task_id = TaskId(\"task_id1\")      job_id = JobId(\"id1\")      task = Task(config_id=\"name\", properties={}, input=[], function=_error, output=[], id=task_id)      submission = _SubmissionManagerFactory._build_manager()._create(task_id)      job = Job(job_id, task, submission.id, task.id)        dispatcher = _OrchestratorFactory._dispatcher      dispatcher._dispatch(job)      assert job.is_failed()      assert 'RuntimeError(\"Something bad has happened\")' in str(job.stacktrace[0])      def test_exception_in_writing_data():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        task_id = TaskId(\"task_id1\")      job_id = JobId(\"id1\")      output = MagicMock()      output.id = DataNodeId(\"output_id\")      output.config_id = \"my_raising_datanode\"      output._is_in_cache = False      output.write.side_effect = ValueError()      task = Task(config_id=\"name\", properties={}, input=[], function=print, output=[output], id=task_id)      submission = _SubmissionManagerFactory._build_manager()._create(task_id)      job = Job(job_id, task, submission.id, task.id)        dispatcher = _OrchestratorFactory._dispatcher        with mock.patch(\"src.taipy.core.data._data_manager._DataManager._get\") as get:          get.return_value = output          dispatcher._dispatch(job)          assert job.is_failed()          assert \"node\" in job.stacktrace[0] "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from src.taipy.core.data import InMemoryDataNode  from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.task._task_model import _TaskModel  from taipy.config.common.scope import Scope      def test_none_properties_attribute_compatible():      model = _TaskModel.from_dict(          {              \"id\": \"id\",              \"config_id\": \"config_id\",              \"parent_id\": \"owner_id\",              \"parent_ids\": [\"parent_id\"],              \"input_ids\": [\"input_id\"],              \"function_name\": \"function_name\",              \"function_module\": \"function_module\",              \"output_ids\": [\"output_id\"],              \"version\": \"latest\",              \"skippable\": False,          }      )      assert len(model.properties) == 0      def test_skippable_compatibility_with_non_existing_output():      model = _TaskModel.from_dict(          {              \"id\": \"id\",              \"config_id\": \"config_id\",              \"owner_id\": \"owner_id\",              \"parent_ids\": [\"parent_id\"],              \"input_ids\": [\"input_id\"],              \"function_name\": \"function_name\",              \"function_module\": \"function_module\",              \"output_ids\": [\"output_id\"],              \"version\": \"latest\",              \"skippable\": False,          }      )      assert not model.skippable      def test_skippable_compatibility_with_no_output():      model = _TaskModel.from_dict(          {              \"id\": \"id\",              \"config_id\": \"config_id\",              \"owner_id\": \"owner_id\",              \"parent_ids\": [\"parent_id\"],              \"input_ids\": [\"input_id\"],              \"function_name\": \"function_name\",              \"function_module\": \"function_module\",              \"output_ids\": [],              \"version\": \"latest\",              \"skippable\": False,          }      )      assert not model.skippable      def test_skippable_compatibility_with_one_output():      manager = _DataManagerFactory._build_manager()      manager._set(InMemoryDataNode(\"cfg_id\", Scope.SCENARIO, id=\"dn_id\"))        model = _TaskModel.from_dict(          {              \"id\": \"id\",              \"config_id\": \"config_id\",              \"owner_id\": \"owner_id\",              \"parent_ids\": [\"parent_id\"],              \"input_ids\": [\"input_id\"],              \"function_name\": \"function_name\",              \"function_module\": \"function_module\",              \"output_ids\": [\"dn_id\"],              \"version\": \"latest\",              \"skippable\": True,          }      )      assert model.skippable      def test_skippable_compatibility_with_many_outputs():      manager = _DataManagerFactory._build_manager()      manager._set(InMemoryDataNode(\"cfg_id\", Scope.SCENARIO, id=\"dn_id\"))      manager._set(InMemoryDataNode(\"cfg_id_2\", Scope.SCENARIO, id=\"dn_2_id\"))      model = _TaskModel.from_dict(          {              \"id\": \"id\",              \"config_id\": \"config_id\",              \"owner_id\": \"owner_id\",              \"parent_ids\": [\"parent_id\"],              \"input_ids\": [\"input_id\"],              \"function_name\": \"function_name\",              \"function_module\": \"function_module\",              \"output_ids\": [\"dn_id\", \"dn_2_id\"],              \"version\": \"latest\",              \"skippable\": True,          }      )      assert model.skippable "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from src.taipy.core.sequence._sequence_converter import _SequenceConverter  from src.taipy.core.sequence.sequence import Sequence  from src.taipy.core.task.task import Task      def test_entity_to_model(sequence):      sequence_model_1 = _SequenceConverter._entity_to_model(sequence)      expected_sequence_model_1 = {          \"id\": \"sequence_id\",          \"owner_id\": \"owner_id\",          \"parent_ids\": [\"parent_id_1\", \"parent_id_2\"],          \"properties\": {},          \"tasks\": [],          \"subscribers\": [],          \"version\": \"random_version_number\",      }      sequence_model_1[\"parent_ids\"] = sorted(sequence_model_1[\"parent_ids\"])      assert sequence_model_1 == expected_sequence_model_1        task_1 = Task(\"task_1\", {}, print)      task_2 = Task(\"task_2\", {}, print)      sequence_2 = Sequence(          {\"name\": \"sequence_2\"},          [task_1, task_2],          \"SEQUENCE_sq_1_SCENARIO_sc\",          \"SCENARIO_sc\",          [\"SCENARIO_sc\"],          [],          \"random_version\",      )      sequence_model_2 = _SequenceConverter._entity_to_model(sequence_2)      expected_sequence_model_2 = {          \"id\": \"SEQUENCE_sq_1_SCENARIO_sc\",          \"owner_id\": \"SCENARIO_sc\",          \"parent_ids\": [\"SCENARIO_sc\"],          \"properties\": {\"name\": \"sequence_2\"},          \"tasks\": [task_1.id, task_2.id],          \"subscribers\": [],          \"version\": \"random_version\",      }      assert sequence_model_2 == expected_sequence_model_2 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from src.taipy.core.data.data_node import DataNode  from src.taipy.core.data.in_memory import InMemoryDataNode  from taipy.config.common.scope import Scope      class FakeDataNode(InMemoryDataNode):      read_has_been_called = 0      write_has_been_called = 0        def __init__(self, config_id, **kwargs):          scope = kwargs.pop(\"scope\", Scope.SCENARIO)          super().__init__(config_id=config_id, scope=scope, **kwargs)        def _read(self, query=None):          self.read_has_been_called += 1        def _write(self, data):          self.write_has_been_called += 1        @classmethod      def storage_type(cls) -> str:          return \"fake_inmemory\"        write = DataNode.write  # Make sure that the writing behavior comes from DataNode      class FakeDataframeDataNode(DataNode):      COLUMN_NAME_1 = \"a\"      COLUMN_NAME_2 = \"b\"        def __init__(self, config_id, default_data_frame, **kwargs):          super().__init__(config_id, **kwargs)          self.data = default_data_frame        def _read(self):          return self.data        @classmethod      def storage_type(cls) -> str:          return \"fake_df_dn\"      class FakeNumpyarrayDataNode(DataNode):      def __init__(self, config_id, default_array, **kwargs):          super().__init__(config_id, **kwargs)          self.data = default_array        def _read(self):          return self.data        @classmethod      def storage_type(cls) -> str:          return \"fake_np_dn\"      class FakeListDataNode(DataNode):      class Row:          def __init__(self, value):              self.value = value        def __init__(self, config_id, **kwargs):          super().__init__(config_id, **kwargs)          self.data = [self.Row(i) for i in range(10)]        def _read(self):          return self.data        @classmethod      def storage_type(cls) -> str:          return \"fake_list_dn\"      class CustomClass:      def __init__(self, a, b):          self.a = a          self.b = b      class FakeCustomDataNode(DataNode):      def __init__(self, config_id, **kwargs):          super().__init__(config_id, **kwargs)          self.data = [CustomClass(i, i * 2) for i in range(10)]        def _read(self):          return self.data      class FakeMultiSheetExcelDataFrameDataNode(DataNode):      def __init__(self, config_id, default_data_frame, **kwargs):          super().__init__(config_id, **kwargs)          self.data = {              \"Sheet1\": default_data_frame,              \"Sheet2\": default_data_frame,          }        def _read(self):          return self.data      class FakeMultiSheetExcelCustomDataNode(DataNode):      def __init__(self, config_id, **kwargs):          super().__init__(config_id, **kwargs)          self.data = {              \"Sheet1\": [CustomClass(i, i * 2) for i in range(10)],              \"Sheet2\": [CustomClass(i, i * 2) for i in range(10)],          }        def _read(self):          return self.data "}
{"text": "import os    import pytest    from src.taipy.core.data._data_fs_repository import _DataFSRepository  from src.taipy.core.data._data_sql_repository import _DataSQLRepository  from src.taipy.core.data.data_node import DataNode, DataNodeId  from src.taipy.core.exceptions import ModelNotFound      class TestDataNodeRepository:      @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_save_and_load(self, data_node, repo, init_sql_repo):          repository = repo()          repository._save(data_node)            obj = repository._load(data_node.id)          assert isinstance(obj, DataNode)        @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_exists(self, data_node, repo, init_sql_repo):          repository = repo()          repository._save(data_node)            assert repository._exists(data_node.id)          assert not repository._exists(\"not-existed-data-node\")        @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_load_all(self, data_node, repo, init_sql_repo):          repository = repo()          for i in range(10):              data_node.id = DataNodeId(f\"data_node-{i}\")              repository._save(data_node)          data_nodes = repository._load_all()            assert len(data_nodes) == 10        @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_load_all_with_filters(self, data_node, repo, init_sql_repo):          repository = repo()            for i in range(10):              data_node.id = DataNodeId(f\"data_node-{i}\")              data_node.owner_id = f\"task-{i}\"              repository._save(data_node)          objs = repository._load_all(filters=[{\"owner_id\": \"task-2\"}])            assert len(objs) == 1        @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_delete(self, data_node, repo, init_sql_repo):          repository = repo()          repository._save(data_node)            repository._delete(data_node.id)            with pytest.raises(ModelNotFound):              repository._load(data_node.id)        @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_delete_all(self, data_node, repo, init_sql_repo):          repository = repo()            for i in range(10):              data_node.id = DataNodeId(f\"data_node-{i}\")              repository._save(data_node)            assert len(repository._load_all()) == 10            repository._delete_all()            assert len(repository._load_all()) == 0        @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_delete_many(self, data_node, repo, init_sql_repo):          repository = repo()            for i in range(10):              data_node.id = DataNodeId(f\"data_node-{i}\")              repository._save(data_node)            objs = repository._load_all()          assert len(objs) == 10          ids = [x.id for x in objs[:3]]          repository._delete_many(ids)            assert len(repository._load_all()) == 7        @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_delete_by(self, data_node, repo, init_sql_repo):          repository = repo()            # Create 5 entities with version 1.0 and 5 entities with version 2.0          for i in range(10):              data_node.id = DataNodeId(f\"data_node-{i}\")              data_node._version = f\"{(i+1) // 5}.0\"              repository._save(data_node)            objs = repository._load_all()          assert len(objs) == 10          repository._delete_by(\"version\", \"1.0\")            assert len(repository._load_all()) == 5        @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_search(self, data_node, repo, init_sql_repo):          repository = repo()            for i in range(10):              data_node.id = DataNodeId(f\"data_node-{i}\")              data_node.owner_id = f\"task-{i}\"              repository._save(data_node)            assert len(repository._load_all()) == 10            objs = repository._search(\"owner_id\", \"task-2\")          assert len(objs) == 1          assert isinstance(objs[0], DataNode)            objs = repository._search(\"owner_id\", \"task-2\", filters=[{\"version\": \"random_version_number\"}])          assert len(objs) == 1          assert isinstance(objs[0], DataNode)            assert repository._search(\"owner_id\", \"task-2\", filters=[{\"version\": \"non_existed_version\"}]) == []        @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_export(self, tmpdir, data_node, repo, init_sql_repo):          repository = repo()          repository._save(data_node)            repository._export(data_node.id, tmpdir.strpath)          dir_path = repository.dir_path if repo == _DataFSRepository else os.path.join(tmpdir.strpath, \"data_node\")            assert os.path.exists(os.path.join(dir_path, f\"{data_node.id}.json\")) "}
{"text": "import pytest    from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.exceptions.exceptions import NoData  from taipy.config.common.scope import Scope  from taipy.config.exceptions.exceptions import InvalidConfigurationId      class TestInMemoryDataNodeEntity:      def test_create(self):          dn = InMemoryDataNode(              \"foobar_bazy\",              Scope.SCENARIO,              DataNodeId(\"id_uio\"),              \"owner_id\",              properties={\"default_data\": \"In memory Data Node\", \"name\": \"my name\"},          )          assert isinstance(dn, InMemoryDataNode)          assert dn.storage_type() == \"in_memory\"          assert dn.config_id == \"foobar_bazy\"          assert dn.scope == Scope.SCENARIO          assert dn.id == \"id_uio\"          assert dn.name == \"my name\"          assert dn.owner_id == \"owner_id\"          assert dn.last_edit_date is not None          assert dn.job_ids == []          assert dn.is_ready_for_reading          assert dn.read() == \"In memory Data Node\"            dn_2 = InMemoryDataNode(\"foo\", Scope.SCENARIO)          assert dn_2.last_edit_date is None          assert not dn_2.is_ready_for_reading            with pytest.raises(InvalidConfigurationId):              InMemoryDataNode(\"foo bar\", Scope.SCENARIO, DataNodeId(\"dn_id\"))        def test_get_user_properties(self):          dn = InMemoryDataNode(\"foo\", Scope.SCENARIO, properties={\"default_data\": 1, \"foo\": \"bar\"})          assert dn._get_user_properties() == {\"foo\": \"bar\"}        def test_read_and_write(self):          no_data_dn = InMemoryDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"))          with pytest.raises(NoData):              assert no_data_dn.read() is None              no_data_dn.read_or_raise()          in_mem_dn = InMemoryDataNode(\"foo\", Scope.SCENARIO, properties={\"default_data\": \"bar\"})          assert isinstance(in_mem_dn.read(), str)          assert in_mem_dn.read() == \"bar\"          in_mem_dn.properties[\"default_data\"] = \"baz\"  # this modifies the default data value but not the data itself          assert in_mem_dn.read() == \"bar\"          in_mem_dn.write(\"qux\")          assert in_mem_dn.read() == \"qux\"          in_mem_dn.write(1998)          assert isinstance(in_mem_dn.read(), int)          assert in_mem_dn.read() == 1998 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from datetime import datetime  from time import sleep    from src.taipy.core._version._version_manager_factory import _VersionManagerFactory  from src.taipy.core.submission._submission_manager_factory import _SubmissionManagerFactory  from src.taipy.core.submission.submission import Submission  from src.taipy.core.submission.submission_status import SubmissionStatus  from src.taipy.core.task.task import Task      def test_create_submission(scenario):      submission_1 = _SubmissionManagerFactory._build_manager()._create(scenario.id)        assert submission_1.id is not None      assert submission_1.entity_id == scenario.id      assert submission_1.jobs == []      assert isinstance(submission_1.creation_date, datetime)      assert submission_1._submission_status == SubmissionStatus.SUBMITTED      def test_get_submission():      submission_manager = _SubmissionManagerFactory._build_manager()        assert submission_manager._get(\"random_submission_id\") is None        submission_1 = submission_manager._create(\"entity_id\")      submission_2 = submission_manager._get(submission_1.id)        assert submission_1.id == submission_2.id      assert submission_1.entity_id == submission_2.entity_id == \"entity_id\"      assert submission_1.jobs == submission_2.jobs      assert submission_1.creation_date == submission_2.creation_date      assert submission_1.submission_status == submission_2.submission_status      def test_get_all_submission():      submission_manager = _SubmissionManagerFactory._build_manager()      version_manager = _VersionManagerFactory._build_manager()        submission_manager._set(Submission(\"entity_id\", \"submission_id\", version=version_manager._get_latest_version()))      for version_name in [\"abc\", \"xyz\"]:          for i in range(10):              submission_manager._set(                  Submission(\"entity_id\", f\"submission_{version_name}_{i}\", version=f\"{version_name}\")              )        assert len(submission_manager._get_all()) == 1        version_manager._set_experiment_version(\"xyz\")      version_manager._set_experiment_version(\"abc\")      assert len(submission_manager._get_all()) == 10      assert len(submission_manager._get_all(\"abc\")) == 10      assert len(submission_manager._get_all(\"xyz\")) == 10      def test_get_latest_submission():      task_1 = Task(\"task_config_1\", {}, print, id=\"task_id_1\")      task_2 = Task(\"task_config_2\", {}, print, id=\"task_id_2\")        submission_manager = _SubmissionManagerFactory._build_manager()      submission_1 = submission_manager._create(task_1.id)      assert submission_manager._get_latest(task_1) == submission_1      assert submission_manager._get_latest(task_2) is None        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      submission_2 = submission_manager._create(task_2.id)      assert submission_manager._get_latest(task_1) == submission_1      assert submission_manager._get_latest(task_2) == submission_2        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      submission_3 = submission_manager._create(task_1.id)      assert submission_manager._get_latest(task_1) == submission_3      assert submission_manager._get_latest(task_2) == submission_2        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      submission_4 = submission_manager._create(task_2.id)      assert submission_manager._get_latest(task_1) == submission_3      assert submission_manager._get_latest(task_2) == submission_4      def test_delete_submission():      submission_manager = _SubmissionManagerFactory._build_manager()        submission = Submission(\"entity_id\", \"submission_id\")      submission_manager._set(submission)        for i in range(10):          submission_manager._set(Submission(\"entity_id\", f\"submission_{i}\"))        assert len(submission_manager._get_all()) == 11      assert isinstance(submission_manager._get(submission.id), Submission)        submission_manager._delete(submission.id)      assert len(submission_manager._get_all()) == 10      assert submission_manager._get(submission.id) is None        submission_manager._delete_all()      assert len(submission_manager._get_all()) == 0 "}
{"text": "from datetime import datetime  from time import sleep    from src.taipy.core import Task  from src.taipy.core._repository.db._sql_connection import _SQLConnection  from src.taipy.core._version._version_manager_factory import _VersionManagerFactory  from src.taipy.core.submission._submission_manager_factory import _SubmissionManagerFactory  from src.taipy.core.submission.submission import Submission  from src.taipy.core.submission.submission_status import SubmissionStatus      def init_managers():      _VersionManagerFactory._build_manager()._delete_all()      _SubmissionManagerFactory._build_manager()._delete_all()      def test_create_submission(scenario, init_sql_repo):      init_managers()        submission_1 = _SubmissionManagerFactory._build_manager()._create(scenario.id)        assert submission_1.id is not None      assert submission_1.entity_id == scenario.id      assert submission_1.jobs == []      assert isinstance(submission_1.creation_date, datetime)      assert submission_1._submission_status == SubmissionStatus.SUBMITTED      def test_get_submission(init_sql_repo):      init_managers()        submission_manager = _SubmissionManagerFactory._build_manager()        submission_1 = submission_manager._create(\"entity_id\")      submission_2 = submission_manager._get(submission_1.id)        assert submission_1.id == submission_2.id      assert submission_1.entity_id == submission_2.entity_id == \"entity_id\"      assert submission_1.jobs == submission_2.jobs      assert submission_1.creation_date == submission_2.creation_date      assert submission_1.submission_status == submission_2.submission_status      def test_get_all_submission(init_sql_repo):      init_managers()        submission_manager = _SubmissionManagerFactory._build_manager()      version_manager = _VersionManagerFactory._build_manager()        submission_manager._set(Submission(\"entity_id\", \"submission_id\", version=version_manager._get_latest_version()))      for version_name in [\"abc\", \"xyz\"]:          for i in range(10):              submission_manager._set(                  Submission(\"entity_id\", f\"submission_{version_name}_{i}\", version=f\"{version_name}\")              )      assert len(submission_manager._get_all()) == 1        version_manager._set_experiment_version(\"xyz\")      version_manager._set_experiment_version(\"abc\")      assert len(submission_manager._get_all()) == 10      assert len(submission_manager._get_all(\"abc\")) == 10      assert len(submission_manager._get_all(\"xyz\")) == 10      def test_get_latest_submission(init_sql_repo):      init_managers()        task_1 = Task(\"task_config_1\", {}, print, id=\"task_id_1\")      task_2 = Task(\"task_config_2\", {}, print, id=\"task_id_2\")        submission_manager = _SubmissionManagerFactory._build_manager()      submission_1 = submission_manager._create(task_1.id)      assert submission_manager._get_latest(task_1) == submission_1      assert submission_manager._get_latest(task_2) is None        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      submission_2 = submission_manager._create(task_2.id)      assert submission_manager._get_latest(task_1) == submission_1      assert submission_manager._get_latest(task_2) == submission_2        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      submission_3 = submission_manager._create(task_1.id)      assert submission_manager._get_latest(task_1) == submission_3      assert submission_manager._get_latest(task_2) == submission_2        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      submission_4 = submission_manager._create(task_2.id)      assert submission_manager._get_latest(task_1) == submission_3      assert submission_manager._get_latest(task_2) == submission_4      def test_delete_submission(init_sql_repo):      init_managers()        submission_manager = _SubmissionManagerFactory._build_manager()        submission = Submission(\"entity_id\", \"submission_id\")      submission_manager._set(submission)        for i in range(10):          submission_manager._set(Submission(\"entity_id\", f\"submission_{i}\"))        assert len(submission_manager._get_all()) == 11      assert isinstance(submission_manager._get(submission.id), Submission)        submission_manager._delete(submission.id)      assert len(submission_manager._get_all()) == 10      assert submission_manager._get(submission.id) is None        submission_manager._delete_all()      assert len(submission_manager._get_all()) == 0 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from importlib.util import find_spec    if find_spec(\"taipy\"):      if find_spec(\"taipy.config\"):          from taipy.config._init import *  # type: ignore        if find_spec(\"taipy.gui\"):          from taipy.gui._init import *  # type: ignore        if find_spec(\"taipy.core\"):          from taipy.core._init import *  # type: ignore        if find_spec(\"taipy.rest\"):          from taipy.rest._init import *  # type: ignore        if find_spec(\"taipy.gui_core\"):          from taipy.gui_core._init import *  # type: ignore        if find_spec(\"taipy.enterprise\"):          from taipy.enterprise._init import *  # type: ignore        if find_spec(\"taipy._run\"):          from taipy._run import _run as run  # type: ignore "}
{"text": "from ._core import Core  from ._entity.submittable import Submittable  from .cycle.cycle import Cycle  from .cycle.cycle_id import CycleId  from .data.data_node import DataNode  from .data.data_node_id import DataNodeId  from .job.job import Job  from .job.job_id import JobId  from .job.status import Status  from .scenario.scenario import Scenario  from .scenario.scenario_id import ScenarioId  from .sequence.sequence import Sequence  from .sequence.sequence_id import SequenceId  from .taipy import (      cancel_job,      clean_all_entities_by_version,      compare_scenarios,      create_global_data_node,      create_scenario,      delete,      delete_job,      delete_jobs,      exists,      export_scenario,      get,      get_cycles,      get_cycles_scenarios,      get_data_nodes,      get_entities_by_config_id,      get_jobs,      get_latest_job,      get_parents,      get_primary,      get_primary_scenarios,      get_scenarios,      get_sequences,      get_tasks,      is_deletable,      is_editable,      is_promotable,      is_readable,      is_submittable,      set,      set_primary,      submit,      subscribe_scenario,      subscribe_sequence,      tag,      unsubscribe_scenario,      unsubscribe_sequence,      untag,  )  from .task.task import Task  from .task.task_id import TaskId "}
{"text": "\"\"\"# Taipy Core    The Taipy Core package is a Python library designed to build powerful, customized, data-driven back-end  applications. It provides the tools to help Python developers transform their algorithms into a  complete back-end application.  More details on the [Taipy Core](../../core/index.md) functionalities are available in the user manual.    To build a Taipy Core application, the first step consists of setting up the Taipy configuration to design  your application's characteristics and behaviors.  Import `Config^` from the `taipy.config^` module, then use the various methods of the `Config^` singleton class to  configure your core application. In particular, configure the  [data nodes](../../core/config/data-node-config.md), [tasks](../../core/config/task-config.md),  and [scenarios](../../core/config/scenario-config.md).  Please refer to the [Core configuration user manual](../../core/config/index.md) for more information and  detailed examples.    Once your application is configured, import module `import taipy as tp` so you can use any function described  in the following section on [Functionc](#functions). In particular, the most used functions are `tp.create_scenario()`,  `tp.get_scenarios()`, `tp.get_data_nodes()`, `tp.submit()`, used to get, create, and submit entities.    !!! Note        Taipy Core provides a runnable service, `Core^` that runs as a service in a dedicated thread. The purpose is to      have a dedicated thread responsible for dispatching the submitted jobs to an available executor for their execution.        In particular, this `Core^` service is automatically run when Core is used with Taipy REST or Taipy GUI. See the      [running services](../../run-deploy/run/running_services.md) page of the user manual for more details.  \"\"\"    from ._init import *  from ._init_version import _read_version  from .common.mongo_default_document import MongoDefaultDocument  from .data.data_node_id import Edit  from .exceptions import exceptions    __version__ = _read_version() "}
{"text": "import json  import os  from pathlib import Path      def _read_version():      with open(f\"{Path(os.path.abspath(__file__)).parent}{os.sep}version.json\") as version_file:          version = json.load(version_file)          version_string = f'{version.get(\"major\", 0)}.{version.get(\"minor\", 0)}.{version.get(\"patch\", 0)}'          if vext := version.get(\"ext\"):              version_string = f\"{version_string}.{vext}\"      return version_string "}
{"text": "from multiprocessing import Lock  from typing import Optional    from taipy.config import Config  from taipy.logger._taipy_logger import _TaipyLogger    from ._backup._backup import _init_backup_file_with_storage_folder  from ._core_cli import _CoreCLI  from ._orchestrator._dispatcher._job_dispatcher import _JobDispatcher  from ._orchestrator._orchestrator import _Orchestrator  from ._orchestrator._orchestrator_factory import _OrchestratorFactory  from ._version._version_manager_factory import _VersionManagerFactory  from .config import CoreSection  from .exceptions.exceptions import CoreServiceIsAlreadyRunning      class Core:      \"\"\"      Core service      \"\"\"        _is_running = False      __lock_is_running = Lock()        __logger = _TaipyLogger._get_logger()        _orchestrator: Optional[_Orchestrator] = None      _dispatcher: Optional[_JobDispatcher] = None        def __init__(self):          \"\"\"          Initialize a Core service.          \"\"\"          pass        def run(self, force_restart=False):          \"\"\"          Start a Core service.            This function checks the configuration, manages application's version,          and starts a dispatcher and lock the Config.          \"\"\"          if self.__class__._is_running:              raise CoreServiceIsAlreadyRunning            with self.__class__.__lock_is_running:              self.__class__._is_running = True            self.__update_core_section()          self.__manage_version()          self.__check_and_block_config()            if self._orchestrator is None:              self._orchestrator = _OrchestratorFactory._build_orchestrator()            self.__start_dispatcher(force_restart)        def stop(self):          \"\"\"          Stop the Core service.            This function stops the dispatcher and unblock the Config for update.          \"\"\"          Config.unblock_update()            if self._dispatcher:              self._dispatcher = _OrchestratorFactory._remove_dispatcher()              self.__logger.info(\"Core service has been stopped.\")            with self.__class__.__lock_is_running:              self.__class__._is_running = False        @staticmethod      def __update_core_section():          _CoreCLI.create_parser()          Config._applied_config._unique_sections[CoreSection.name]._update(_CoreCLI.parse_arguments())        @staticmethod      def __manage_version():          _VersionManagerFactory._build_manager()._manage_version()          Config._applied_config._unique_sections[CoreSection.name]._update(              {\"version_number\": _VersionManagerFactory._build_manager()._get_latest_version()}          )        @staticmethod      def __check_and_block_config():          Config.check()          Config.block_update()          _init_backup_file_with_storage_folder()        def __start_dispatcher(self, force_restart):          if dispatcher := _OrchestratorFactory._build_dispatcher(force_restart=force_restart):              self._dispatcher = dispatcher            if Config.job_config.is_development:              _Orchestrator._check_and_execute_jobs_if_development_mode() "}
{"text": "from typing import Dict    from taipy._cli._base_cli import _CLI    from .config import CoreSection      class _CoreCLI:      \"\"\"Command-line interface for Taipy Core application.\"\"\"        __MODE_ARGS: Dict[str, Dict] = {          \"--development\": {              \"action\": \"store_true\",              \"dest\": \"taipy_development\",              \"help\": \"\"\"                  When execute Taipy application in `development` mode, all entities from the previous development version                  will be deleted before running new Taipy application.              \"\"\",          },          \"--experiment\": {              \"dest\": \"taipy_experiment\",              \"nargs\": \"?\",              \"const\": \"\",              \"metavar\": \"VERSION\",              \"help\": \"\"\"                  When execute Taipy application in `experiment` mode, the current Taipy application is saved to a new                  version. If version name already exists, check for compatibility with current Python Config and run the                  application. Without being specified, the version number will be a random string.              \"\"\",          },          \"--production\": {              \"dest\": \"taipy_production\",              \"nargs\": \"?\",              \"const\": \"\",              \"metavar\": \"VERSION\",              \"help\": \"\"\"                  When execute in `production` mode, the current version is used in production. All production versions                  should have the same configuration and share all entities. Without being specified, the latest version                  is used.              \"\"\",          },      }        __FORCE_ARGS: Dict[str, Dict] = {          \"--force\": {              \"dest\": \"taipy_force\",              \"action\": \"store_true\",              \"help\": \"\"\"                  Force override the configuration of the version if existed and run the application. Default to False.              \"\"\",          },          \"--no-force\": {              \"dest\": \"no_taipy_force\",              \"action\": \"store_true\",              \"help\": \"Stop the application if any Config conflict exists.\",          },      }        @classmethod      def create_parser(cls):          core_parser = _CLI._add_groupparser(\"Taipy Core\", \"Optional arguments for Taipy Core service\")            mode_group = core_parser.add_mutually_exclusive_group()          for mode_arg, mode_arg_dict in cls.__MODE_ARGS.items():              mode_group.add_argument(mode_arg, cls.__add_taipy_prefix(mode_arg), **mode_arg_dict)            force_group = core_parser.add_mutually_exclusive_group()          for force_arg, force_arg_dict in cls.__FORCE_ARGS.items():              force_group.add_argument(cls.__add_taipy_prefix(force_arg), **force_arg_dict)        @classmethod      def create_run_parser(cls):          run_parser = _CLI._add_subparser(\"run\", help=\"Run a Taipy application.\")          mode_group = run_parser.add_mutually_exclusive_group()          for mode_arg, mode_arg_dict in cls.__MODE_ARGS.items():              mode_group.add_argument(mode_arg, **mode_arg_dict)            force_group = run_parser.add_mutually_exclusive_group()          for force_arg, force_arg_dict in cls.__FORCE_ARGS.items():              force_group.add_argument(force_arg, **force_arg_dict)        @classmethod      def parse_arguments(cls):          args = _CLI._parse()          as_dict = {}          if args.taipy_development:              as_dict[CoreSection._MODE_KEY] = CoreSection._DEVELOPMENT_MODE          elif args.taipy_experiment is not None:              as_dict[CoreSection._MODE_KEY] = CoreSection._EXPERIMENT_MODE              as_dict[CoreSection._VERSION_NUMBER_KEY] = args.taipy_experiment          elif args.taipy_production is not None:              as_dict[CoreSection._MODE_KEY] = CoreSection._PRODUCTION_MODE              as_dict[CoreSection._VERSION_NUMBER_KEY] = args.taipy_production            if args.taipy_force:              as_dict[CoreSection._FORCE_KEY] = True          elif args.no_taipy_force:              as_dict[CoreSection._FORCE_KEY] = False            return as_dict        @classmethod      def __add_taipy_prefix(cls, key: str):          if key.startswith(\"--no-\"):              return key[:5] + \"taipy-\" + key[5:]            return key[:2] + \"taipy-\" + key[2:] "}
{"text": "import json  import re  from datetime import datetime, timedelta      class _Decoder(json.JSONDecoder):      def __init__(self, *args, **kwargs):          json.JSONDecoder.__init__(self, object_hook=self.object_hook, *args, **kwargs)        def _str_to_timedelta(self, timedelta_str: str) -> timedelta:          \"\"\"          Parse a time string e.g. (2h13m) into a timedelta object.            :param timedelta_str: A string identifying a duration.  (eg. 2h13m)          :return datetime.timedelta: A datetime.timedelta object          \"\"\"          regex = re.compile(              r\"^((?P<days>[\\.\\d]+?)d)? *\"              r\"((?P<hours>[\\.\\d]+?)h)? *\"              r\"((?P<minutes>[\\.\\d]+?)m)? *\"              r\"((?P<seconds>[\\.\\d]+?)s)?$\"          )          parts = regex.match(timedelta_str)          if not parts:              raise TypeError(\"Can not deserialize string into timedelta\")          time_params = {name: float(param) for name, param in parts.groupdict().items() if param}          # mypy has an issue with dynamic keyword parameters, hence the type ignore on the line bellow.          return timedelta(**time_params)  # type: ignore        def object_hook(self, source):          if source.get(\"__type__\") == \"Datetime\":              return datetime.fromisoformat(source.get(\"__value__\"))          if source.get(\"__type__\") == \"Timedelta\":              return self._str_to_timedelta(source.get(\"__value__\"))          else:              return source      def loads(d):      return json.loads(d, cls=_Decoder) "}
{"text": "import pathlib  from abc import abstractmethod  from typing import Any, Dict, Generic, Iterable, List, Optional, TypeVar, Union    ModelType = TypeVar(\"ModelType\")  Entity = TypeVar(\"Entity\")      class _AbstractRepository(Generic[ModelType, Entity]):      @abstractmethod      def _save(self, entity: Entity):          \"\"\"          Save an entity in the repository.            Parameters:              entity: The data from an object.          \"\"\"          raise NotImplementedError        @abstractmethod      def _exists(self, entity_id: str) -> bool:          \"\"\"          Check if an entity with id entity_id exists in the repository.          Parameters:              entity_id: The entity id, i.e., its primary key.            Returns:              True if the entity id exists.          \"\"\"          raise NotImplementedError        @abstractmethod      def _load(self, entity_id: str) -> Entity:          \"\"\"          Retrieve the entity data from the repository.          Parameters:              entity_id: The entity id, i.e., its primary key.            Returns:              An entity.          \"\"\"          raise NotImplementedError        @abstractmethod      def _load_all(self, filters: Optional[List[Dict]] = None) -> List[Entity]:          \"\"\"          Retrieve all the entities' data from the repository taking any passed filter into account.            Returns:              A list of entities.          \"\"\"          raise NotImplementedError        @abstractmethod      def _delete(self, entity_id: str):          \"\"\"          Delete an entity in the repository.            Parameters:              entity_id: The id of the entity to be deleted.          \"\"\"          raise NotImplementedError        @abstractmethod      def _delete_all(self):          \"\"\"          Delete all entities from the repository.          \"\"\"          raise NotImplementedError        @abstractmethod      def _delete_many(self, ids: Iterable[str]):          \"\"\"          Delete all entities from the list of ids from the repository.            Parameters:              ids: List of ids to be deleted.          \"\"\"          raise NotImplementedError        @abstractmethod      def _delete_by(self, attribute: str, value: str):          \"\"\"          Delete all entities from the list of ids from the repository.            Parameters:              attribute: The entity property that is the key to the search.              value: The value of the attribute that are being searched.          \"\"\"          raise NotImplementedError        @abstractmethod      def _search(self, attribute: str, value: Any, filters: Optional[List[Dict]] = None) -> List[Entity]:          \"\"\"          Parameters:              attribute: The entity property that is the key to the search.              value: The value of the attribute that are being searched.            Returns:              A list of entities that match the search criteria.          \"\"\"          raise NotImplementedError        @abstractmethod      def _export(self, entity_id: str, folder_path: Union[str, pathlib.Path]):          \"\"\"          Export an entity from the repository.            Parameters:              entity_id (str): The id of the entity to be exported.              folder_path (Union[str, pathlib.Path]): The folder path to export the entity to.          \"\"\"          raise NotImplementedError "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import json  from datetime import datetime, timedelta  from enum import Enum  from typing import Any      class _Encoder(json.JSONEncoder):      def _timedelta_to_str(self, obj: timedelta) -> str:          total_seconds = obj.total_seconds()          return (              f\"{int(total_seconds // 86400)}d\"              f\"{int(total_seconds % 86400 // 3600)}h\"              f\"{int(total_seconds % 3600 // 60)}m\"              f\"{int(total_seconds % 60)}s\"          )        def default(self, o: Any):          if isinstance(o, Enum):              result = o.value          elif isinstance(o, datetime):              result = {\"__type__\": \"Datetime\", \"__value__\": o.isoformat()}          elif isinstance(o, timedelta):              result = {\"__type__\": \"Timedelta\", \"__value__\": self._timedelta_to_str(o)}          else:              result = json.JSONEncoder.default(self, o)          return result      def dumps(d):      return json.dumps(d, cls=_Encoder) "}
{"text": "from abc import ABC, abstractmethod      class _AbstractConverter(ABC):      @classmethod      @abstractmethod      def _entity_to_model(cls, entity):          raise NotImplementedError        @classmethod      @abstractmethod      def _model_to_entity(cls, model):          raise NotImplementedError "}
{"text": "import dataclasses  import enum  import json  from typing import Any, Dict    from sqlalchemy import Table    from ._decoder import _Decoder  from ._encoder import _Encoder      class _BaseModel:      __table__: Table        def __iter__(self):          for attr, value in self.__dict__.items():              yield attr, value        def to_dict(self) -> Dict[str, Any]:          model_dict = {**dataclasses.asdict(self)}            for k, v in model_dict.items():              if isinstance(v, enum.Enum):                  model_dict[k] = repr(v)          return model_dict        @staticmethod      def _serialize_attribute(value):          return json.dumps(value, ensure_ascii=False, cls=_Encoder)        @staticmethod      def _deserialize_attribute(value):          if isinstance(value, str):              return json.loads(value.replace(\"'\", '\"'), cls=_Decoder)          return value        @staticmethod      def from_dict(data: Dict[str, Any]):          pass        def to_list(self):          pass "}
{"text": "import sqlite3  from functools import lru_cache  from sqlite3 import Connection    from sqlalchemy.dialects import sqlite  from sqlalchemy.schema import CreateTable    from taipy.config.config import Config    from ...exceptions import MissingRequiredProperty      def dict_factory(cursor, row):      d = {}      for idx, col in enumerate(cursor.description):          d[col[0]] = row[idx]      return d      class _SQLConnection:      _connection = None        @classmethod      def init_db(cls):          if cls._connection:              return cls._connection            cls._connection = _build_connection()          cls._connection.row_factory = dict_factory            from ..._version._version_model import _VersionModel          from ...cycle._cycle_model import _CycleModel          from ...data._data_model import _DataNodeModel          from ...job._job_model import _JobModel          from ...scenario._scenario_model import _ScenarioModel          from ...submission._submission_model import _SubmissionModel          from ...task._task_model import _TaskModel            cls._connection.execute(              str(CreateTable(_CycleModel.__table__, if_not_exists=True).compile(dialect=sqlite.dialect()))          )          cls._connection.execute(              str(CreateTable(_DataNodeModel.__table__, if_not_exists=True).compile(dialect=sqlite.dialect()))          )          cls._connection.execute(              str(CreateTable(_JobModel.__table__, if_not_exists=True).compile(dialect=sqlite.dialect()))          )          cls._connection.execute(              str(CreateTable(_ScenarioModel.__table__, if_not_exists=True).compile(dialect=sqlite.dialect()))          )          cls._connection.execute(              str(CreateTable(_TaskModel.__table__, if_not_exists=True).compile(dialect=sqlite.dialect()))          )          cls._connection.execute(              str(CreateTable(_VersionModel.__table__, if_not_exists=True).compile(dialect=sqlite.dialect()))          )          cls._connection.execute(              str(CreateTable(_SubmissionModel.__table__, if_not_exists=True).compile(dialect=sqlite.dialect()))          )            return cls._connection      def _build_connection() -> Connection:      # Set SQLite threading mode to Serialized, means that threads may share the module, connections and cursors      sqlite3.threadsafety = 3        properties = Config.core.repository_properties      try:          db_location = properties[\"db_location\"]      except KeyError:          raise MissingRequiredProperty(\"Missing property db_location.\")        return __build_connection(db_location)      @lru_cache  def __build_connection(db_location: str):      return sqlite3.connect(db_location, check_same_thread=False) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from sqlalchemy.orm import declarative_base, registry    _SQLBaseModel = declarative_base()  mapper_registry = registry() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "  import os    from taipy.config import Config    __BACKUP_FILE_PATH_ENVIRONMENT_VARIABLE_NAME = \"TAIPY_BACKUP_FILE_PATH\"      def _init_backup_file_with_storage_folder():      if preserve_file_path := os.getenv(__BACKUP_FILE_PATH_ENVIRONMENT_VARIABLE_NAME):          with open(preserve_file_path, \"a\") as f:              f.write(f\"{Config.core.storage_folder}\\n\")      def _append_to_backup_file(new_file_path: str):      if preserve_file_path := os.getenv(__BACKUP_FILE_PATH_ENVIRONMENT_VARIABLE_NAME):          storage_folder = os.path.abspath(Config.core.storage_folder) + os.sep          if not os.path.abspath(new_file_path).startswith(storage_folder):              with open(preserve_file_path, \"a\") as f:                  f.write(f\"{new_file_path}\\n\")      def _remove_from_backup_file(to_remove_file_path: str):      if preserve_file_path := os.getenv(__BACKUP_FILE_PATH_ENVIRONMENT_VARIABLE_NAME, None):          storage_folder = os.path.abspath(Config.core.storage_folder) + os.sep          if not os.path.abspath(to_remove_file_path).startswith(storage_folder):              try:                  with open(preserve_file_path, \"r+\") as f:                      old_backup = f.read()                      to_remove_file_path = to_remove_file_path + \"\\n\"                        # To avoid removing the file path of different data nodes that are pointing                      # to the same file. We will only replace the file path only once.                      if old_backup.startswith(to_remove_file_path):                          new_backup = old_backup.replace(to_remove_file_path, \"\", 1)                      else:                          new_backup = old_backup.replace(\"\\n\" + to_remove_file_path, \"\\n\", 1)                        if new_backup is not old_backup:                          f.seek(0)                          f.write(new_backup)                          f.truncate()              except Exception:                  pass      def _replace_in_backup_file(old_file_path: str, new_file_path: str):      _remove_from_backup_file(old_file_path)      _append_to_backup_file(new_file_path) "}
{"text": "from taipy.config import _inject_section  from taipy.config.checker._checker import _Checker  from taipy.config.common.frequency import Frequency  # type: ignore  from taipy.config.common.scope import Scope  # type: ignore  from taipy.config.config import Config  # type: ignore  from taipy.config.global_app.global_app_config import GlobalAppConfig  # type: ignore    from .checkers._config_id_checker import _ConfigIdChecker  from .checkers._core_section_checker import _CoreSectionChecker  from .checkers._data_node_config_checker import _DataNodeConfigChecker  from .checkers._job_config_checker import _JobConfigChecker  from .checkers._scenario_config_checker import _ScenarioConfigChecker  from .checkers._task_config_checker import _TaskConfigChecker  from .core_section import CoreSection  from .data_node_config import DataNodeConfig  from .job_config import JobConfig  from .migration_config import MigrationConfig  from .scenario_config import ScenarioConfig  from .task_config import TaskConfig    _inject_section(      JobConfig,      \"job_config\",      JobConfig.default_config(),      [(\"configure_job_executions\", JobConfig._configure)],      add_to_unconflicted_sections=True,  )  _inject_section(      DataNodeConfig,      \"data_nodes\",      DataNodeConfig.default_config(),      [          (\"configure_data_node\", DataNodeConfig._configure),          (\"configure_data_node_from\", DataNodeConfig._configure_from),          (\"set_default_data_node_configuration\", DataNodeConfig._set_default_configuration),          (\"configure_csv_data_node\", DataNodeConfig._configure_csv),          (\"configure_json_data_node\", DataNodeConfig._configure_json),          (\"configure_parquet_data_node\", DataNodeConfig._configure_parquet),          (\"configure_sql_table_data_node\", DataNodeConfig._configure_sql_table),          (\"configure_sql_data_node\", DataNodeConfig._configure_sql),          (\"configure_mongo_collection_data_node\", DataNodeConfig._configure_mongo_collection),          (\"configure_in_memory_data_node\", DataNodeConfig._configure_in_memory),          (\"configure_pickle_data_node\", DataNodeConfig._configure_pickle),          (\"configure_excel_data_node\", DataNodeConfig._configure_excel),          (\"configure_generic_data_node\", DataNodeConfig._configure_generic),      ],  )  _inject_section(      TaskConfig,      \"tasks\",      TaskConfig.default_config(),      [          (\"configure_task\", TaskConfig._configure),          (\"set_default_task_configuration\", TaskConfig._set_default_configuration),      ],  )  _inject_section(      ScenarioConfig,      \"scenarios\",      ScenarioConfig.default_config(),      [          (\"configure_scenario\", ScenarioConfig._configure),          (\"set_default_scenario_configuration\", ScenarioConfig._set_default_configuration),      ],  )  _inject_section(      MigrationConfig,      \"migration_functions\",      MigrationConfig.default_config(),      [(\"add_migration_function\", MigrationConfig._add_migration_function)],      add_to_unconflicted_sections=True,  )  _inject_section(      CoreSection,      \"core\",      CoreSection.default_config(),      [(\"configure_core\", CoreSection._configure)],      add_to_unconflicted_sections=True,  )    _Checker.add_checker(_ConfigIdChecker)  _Checker.add_checker(_CoreSectionChecker)  _Checker.add_checker(_DataNodeConfigChecker)  _Checker.add_checker(_JobConfigChecker)  # We don't need to add _MigrationConfigChecker because it is run only when the Core service is run.  _Checker.add_checker(_TaskConfigChecker)  _Checker.add_checker(_ScenarioConfigChecker) "}
{"text": "import collections.abc  from copy import deepcopy  from typing import Any, Callable, Dict, Optional, Union    from taipy.config._config import _Config  from taipy.config.common._template_handler import _TemplateHandler as _tpl  from taipy.config.config import Config  from taipy.config.section import Section  from taipy.config.unique_section import UniqueSection      class MigrationConfig(UniqueSection):      \"\"\"      Configuration fields needed to register migration functions from an old version to newer one.        Attributes:          migration_fcts (Dict[str, Dict[str, Callable]]): A dictionary that maps the version that entities are              migrated from to the migration functions.          **properties (dict[str, Any]): A dictionary of additional properties.      \"\"\"        name = \"VERSION_MIGRATION\"        _MIGRATION_FCTS_KEY = \"migration_fcts\"        def __init__(          self,          migration_fcts: Dict[str, Dict[str, Callable]],          **properties,      ):          self.migration_fcts = migration_fcts            super().__init__(**properties)        def __copy__(self):          return MigrationConfig(              deepcopy(self.migration_fcts),              **deepcopy(self._properties),          )        def _clean(self):          self.migration_fcts.clear()          self._properties.clear()        def __getattr__(self, item: str) -> Optional[Any]:          return _tpl._replace_templates(self._properties.get(item))  # type: ignore        @classmethod      def default_config(cls):          return MigrationConfig({})        def _to_dict(self):          return {              self._MIGRATION_FCTS_KEY: self.migration_fcts,              **self._properties,          }        @classmethod      def _from_dict(cls, as_dict: Dict[str, Any], id: str, config: Optional[_Config]):          return MigrationConfig(**as_dict)        def _update(self, as_dict, default_section=None):          def deep_update(d, u):              for k, v in u.items():                  if isinstance(v, collections.abc.Mapping):                      d[k] = deep_update(d.get(k, {}), v)                  else:                      d[k] = v              return d            migration_fcts = as_dict.pop(self._MIGRATION_FCTS_KEY)          deep_update(self.migration_fcts, migration_fcts)            self._properties.update(as_dict)        @staticmethod      def _add_migration_function(          target_version: str,          config: Union[Section, str],          migration_fct: Callable,          **properties,      ):          \"\"\"Add a migration function for a Configuration to migrate entities to the target version.            Parameters:              target_version (str): The production version that entities are migrated to.              config (Union[Section, str]): The configuration or the `id` of the config that needs to migrate.              migration_fct (Callable): Migration function that takes an entity as input and returns a new entity                  that is compatible with the target production version.              **properties (Dict[str, Any]): A keyworded variable length list of additional arguments.          Returns:              `MigrationConfig^`: The Migration configuration.          \"\"\"          config_id = config if isinstance(config, str) else config.id          migration_fcts = {target_version: {config_id: migration_fct}}            section = MigrationConfig(              migration_fcts,              **properties,          )          Config._register(section)          return Config.unique_sections[MigrationConfig.name] "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from copy import copy  from typing import Any, Dict, Optional, Union    from taipy.config import Config  from taipy.config._config import _Config  from taipy.config.common._template_handler import _TemplateHandler as _tpl  from taipy.config.unique_section import UniqueSection    from ..exceptions.exceptions import ModeNotAvailable      class JobConfig(UniqueSection):      \"\"\"      Configuration fields related to the jobs' executions.        Parameters:          mode (str): The Taipy operating mode. By default, the \"development\" mode is set for testing and debugging the              executions of jobs. A \"standalone\" mode is also available.          **properties (dict[str, any]): A dictionary of additional properties.      \"\"\"        name = \"JOB\"        _MODE_KEY = \"mode\"      _STANDALONE_MODE = \"standalone\"      _DEVELOPMENT_MODE = \"development\"      _DEFAULT_MODE = _DEVELOPMENT_MODE      _MODES = [_STANDALONE_MODE, _DEVELOPMENT_MODE]        def __init__(self, mode: Optional[str] = None, **properties):          self.mode = mode or self._DEFAULT_MODE          self._config = self._create_config(self.mode, **properties)          super().__init__(**properties)        def __copy__(self):          return JobConfig(self.mode, **copy(self._properties))        def __getattr__(self, key: str) -> Optional[Any]:          return self._config.get(key, None)        @classmethod      def default_config(cls):          return JobConfig(cls._DEFAULT_MODE)        def _clean(self):          self.mode = self._DEFAULT_MODE          self._config = self._create_config(self.mode)        def _to_dict(self):          as_dict = {}          if self.mode is not None:              as_dict[self._MODE_KEY] = self.mode          as_dict.update(self._config)          return as_dict        @classmethod      def _from_dict(cls, config_as_dict: Dict[str, Any], id=None, config: Optional[_Config] = None):          mode = config_as_dict.pop(cls._MODE_KEY, None)          job_config = JobConfig(mode, **config_as_dict)          return job_config        def _update(self, as_dict: Dict[str, Any], default_section=None):          mode = _tpl._replace_templates(as_dict.pop(self._MODE_KEY, self.mode))          if self.mode != mode:              self.mode = mode              self._config = self._create_config(self.mode, **as_dict)          if self._config is not None:              self._update_config(as_dict)        @staticmethod      def _configure(          mode: Optional[str] = None, max_nb_of_workers: Optional[Union[int, str]] = None, **properties      ) -> \"JobConfig\":          \"\"\"Configure job execution.            Parameters:              mode (Optional[str]): The job execution mode.                  Possible values are: *\"standalone\"* (the default value) or *\"development\"*.              max_nb_of_workers (Optional[int, str]): Parameter used only in default *\"standalone\"* mode.                  This indicates the maximum number of jobs able to run in parallel.<br/>                  The default value is 1.<br/>                  A string can be provided to dynamically set the value using an environment                  variable. The string must follow the pattern: `ENV[&lt;env_var&gt;]` where                  `&lt;env_var&gt;` is the name of an environment variable.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new job execution configuration.          \"\"\"          section = JobConfig(mode, max_nb_of_workers=max_nb_of_workers, **properties)          Config._register(section)          return Config.unique_sections[JobConfig.name]        def _update_config(self, config_as_dict: Dict[str, Any]):          for k, v in config_as_dict.items():              type_to_convert = type(self.get_default_config(self.mode).get(k, None)) or str              value = _tpl._replace_templates(v, type_to_convert)              if value is not None:                  self._config[k] = value        @property      def is_standalone(self) -> bool:          \"\"\"True if the config is set to standalone mode\"\"\"          return self.mode == self._STANDALONE_MODE        @property      def is_development(self) -> bool:          \"\"\"True if the config is set to development mode\"\"\"          return self.mode == self._DEVELOPMENT_MODE        @classmethod      def get_default_config(cls, mode: str) -> Dict[str, Any]:          if cls.is_standalone:  # type: ignore              return {\"max_nb_of_workers\": 1}          if cls.is_development:              return {}          raise ModeNotAvailable(mode)        @classmethod      def _create_config(cls, mode, **properties):          return {**cls.get_default_config(mode), **properties} "}
{"text": "from typing import Set    from taipy.config._config import _Config  from taipy.config.checker._checkers._config_checker import _ConfigChecker  from taipy.config.checker.issue_collector import IssueCollector    from ..core_section import CoreSection      class _CoreSectionChecker(_ConfigChecker):        _ACCEPTED_REPOSITORY_TYPES: Set[str] = {\"filesystem\", \"sql\"}        def __init__(self, config: _Config, collector: IssueCollector):          super().__init__(config, collector)        def _check(self) -> IssueCollector:          if core_section := self._config._unique_sections.get(CoreSection.name):              self._check_repository_type(core_section)          return self._collector        def _check_repository_type(self, core_section: CoreSection):          value = core_section.repository_type          if value not in self._ACCEPTED_REPOSITORY_TYPES:              self._warning(                  core_section._REPOSITORY_TYPE_KEY,                  value,                  f'Value \"{value}\" for field {core_section._REPOSITORY_TYPE_KEY} of the CoreSection is not supported. '                  f'Default value \"filesystem\" is applied.',              ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from taipy.config._config import _Config  from taipy.config.checker._checkers._config_checker import _ConfigChecker  from taipy.config.checker.issue_collector import IssueCollector    from ..._version._version_manager_factory import _VersionManagerFactory  from ..migration_config import MigrationConfig      class _MigrationConfigChecker(_ConfigChecker):      def __init__(self, config: _Config, collector: IssueCollector):          super().__init__(config, collector)        def _check(self) -> IssueCollector:          if migration_config := self._config._unique_sections.get(MigrationConfig.name):              self._check_if_entity_property_key_used_is_predefined(migration_config)                migration_fcts = migration_config.migration_fcts                for target_version, migration_functions in migration_config.migration_fcts.items():                  for config_id, migration_function in migration_functions.items():                      self._check_callable(target_version, config_id, migration_function)                self._check_valid_production_version(migration_fcts)              self._check_migration_from_productions_to_productions_exist(migration_fcts)            return self._collector        def _check_callable(self, target_version, config_id, migration_function):          if not callable(migration_function):              self._error(                  MigrationConfig._MIGRATION_FCTS_KEY,                  migration_function,                  f\"The migration function of config `{config_id}` from version {target_version}\"                  f\" must be populated with Callable value.\",              )        def _check_valid_production_version(self, migration_fcts):          for target_version in migration_fcts.keys():              if target_version not in _VersionManagerFactory._build_manager()._get_production_versions():                  self._error(                      MigrationConfig._MIGRATION_FCTS_KEY,                      target_version,                      \"The target version for a migration function must be a production version.\",                  )        def _check_migration_from_productions_to_productions_exist(self, migration_fcts):          production_versions = _VersionManagerFactory._build_manager()._get_production_versions()          for source_version, target_version in zip(production_versions[:-1], production_versions[1:]):              if not migration_fcts.get(target_version):                  self._info(                      \"target_version\",                      None,                      f'There is no migration function from production version \"{source_version}\"'                      f' to version \"{target_version}\".',                  ) "}
{"text": "from typing import Dict    from taipy.config._config import _Config  from taipy.config.checker._checkers._config_checker import _ConfigChecker  from taipy.config.checker.issue_collector import IssueCollector    from ..data_node_config import DataNodeConfig  from ..job_config import JobConfig      class _JobConfigChecker(_ConfigChecker):      def __init__(self, config: _Config, collector: IssueCollector):          super().__init__(config, collector)        def _check(self) -> IssueCollector:          if job_config := self._config._unique_sections.get(JobConfig.name):              data_node_configs = self._config._sections[DataNodeConfig.name]              self._check_multiprocess_mode(job_config, data_node_configs)          return self._collector        def _check_multiprocess_mode(self, job_config: JobConfig, data_node_configs: Dict[str, DataNodeConfig]):          if job_config.is_standalone:              for cfg_id, data_node_config in data_node_configs.items():                  if data_node_config.storage_type == DataNodeConfig._STORAGE_TYPE_VALUE_IN_MEMORY:                      self._error(                          DataNodeConfig._STORAGE_TYPE_KEY,                          data_node_config.storage_type,                          f\"DataNode `{cfg_id}`: In-memory storage type can ONLY be used in \"                          f\"{JobConfig._DEVELOPMENT_MODE} mode.\",                      ) "}
{"text": "from typing import Dict, List    from taipy.config._config import _Config  from taipy.config.checker._checkers._config_checker import _ConfigChecker  from taipy.config.checker.issue_collector import IssueCollector      class _ConfigIdChecker(_ConfigChecker):      def __init__(self, config: _Config, collector: IssueCollector):          super().__init__(config, collector)        def _check(self) -> IssueCollector:          existing_config_ids: Dict[str, List[str]] = dict()          for entity_type, section_dictionary in self._config._sections.items():              for config_id in section_dictionary.keys():                  if config_id in existing_config_ids.keys():                      existing_config_ids[config_id].append(entity_type)                  else:                      existing_config_ids[config_id] = [entity_type]            for config_id, entity_types in existing_config_ids.items():              if config_id != \"default\" and len(entity_types) > 1:                  self._error(                      \"config_id\",                      config_id,                      f\"`{config_id}` is used as the config_id of multiple configurations {str(entity_types)}\",                  ) "}
{"text": "from taipy.config._config import _Config  from taipy.config.checker._checkers._config_checker import _ConfigChecker  from taipy.config.checker.issue_collector import IssueCollector    from ..data_node_config import DataNodeConfig  from ..task_config import TaskConfig      class _TaskConfigChecker(_ConfigChecker):      def __init__(self, config: _Config, collector: IssueCollector):          super().__init__(config, collector)        def _check(self) -> IssueCollector:          task_configs = self._config._sections[TaskConfig.name]          for task_config_id, task_config in task_configs.items():              if task_config_id != _Config.DEFAULT_KEY:                  self._check_existing_config_id(task_config)                  self._check_if_entity_property_key_used_is_predefined(task_config)                  self._check_existing_function(task_config_id, task_config)                  self._check_inputs(task_config_id, task_config)                  self._check_outputs(task_config_id, task_config)          return self._collector        def _check_inputs(self, task_config_id: str, task_config: TaskConfig):          self._check_children(              TaskConfig, task_config_id, task_config._INPUT_KEY, task_config.input_configs, DataNodeConfig          )        def _check_outputs(self, task_config_id: str, task_config: TaskConfig):          self._check_children(              TaskConfig, task_config_id, task_config._OUTPUT_KEY, task_config.output_configs, DataNodeConfig          )        def _check_existing_function(self, task_config_id: str, task_config: TaskConfig):          if not task_config.function:              self._error(                  task_config._FUNCTION,                  task_config.function,                  f\"{task_config._FUNCTION} field of TaskConfig `{task_config_id}` is empty.\",              )          else:              if not callable(task_config.function):                  self._error(                      task_config._FUNCTION,                      task_config.function,                      f\"{task_config._FUNCTION} field of TaskConfig `{task_config_id}` must be\"                      f\" populated with Callable value.\",                  ) "}
{"text": "from dataclasses import dataclass, field  from datetime import datetime  from functools import singledispatch  from typing import Any, Optional    from ..common._repr_enum import _ReprEnum  from ..exceptions.exceptions import InvalidEventAttributeName, InvalidEventOperation      class EventOperation(_ReprEnum):      \"\"\"Enum representing a type of operation performed on a Core entity.        `EventOperation` is used as an attribute of the `Event^` object to describe the      operation performed on an entity.<br>      The possible operations are `CREATION`, `UPDATE`, `DELETION`, or `SUBMISSION`.      \"\"\"        CREATION = 1      UPDATE = 2      DELETION = 3      SUBMISSION = 4      class EventEntityType(_ReprEnum):      \"\"\"Enum representing an entity type.        `EventEntityType` is used as an attribute of the `Event^` object to describe      an entity that was changed.<br>      The possible operations are `CYCLE`, `SCENARIO`, `SEQUENCE`, `TASK`, `DATA_NODE`, `JOB` or `SUBMISSION`.      \"\"\"        CYCLE = 1      SCENARIO = 2      SEQUENCE = 3      TASK = 4      DATA_NODE = 5      JOB = 6      SUBMISSION = 7      _NO_ATTRIBUTE_NAME_OPERATIONS = set([EventOperation.CREATION, EventOperation.DELETION, EventOperation.SUBMISSION])  _UNSUBMITTABLE_ENTITY_TYPES = (EventEntityType.CYCLE, EventEntityType.DATA_NODE, EventEntityType.JOB)  _ENTITY_TO_EVENT_ENTITY_TYPE = {      \"scenario\": EventEntityType.SCENARIO,      \"sequence\": EventEntityType.SEQUENCE,      \"task\": EventEntityType.TASK,      \"data\": EventEntityType.DATA_NODE,      \"job\": EventEntityType.JOB,      \"cycle\": EventEntityType.CYCLE,      \"submission\": EventEntityType.SUBMISSION,  }      @dataclass(frozen=True)  class Event:      \"\"\"Event object used to notify any change in the Core service.        An event holds the necessary attributes to identify the change.        Attributes:          entity_type (EventEntityType^): Type of the entity that was changed (`DataNode^`,              `Scenario^`, `Cycle^`, etc. ).          entity_id (Optional[str]): Unique identifier of the entity that was changed.          operation (EventOperation^): Enum describing the operation (among `CREATION`, `UPDATE`, `DELETION`,              and `SUBMISSION`) that was performed on the entity.          attribute_name (Optional[str]): Name of the entity's attribute changed. Only relevant for `UPDATE`              operations          attribute_value (Optional[str]): Name of the entity's attribute changed. Only relevant for `UPDATE`              operations          metadata (dict): A dict of additional medata about the source of this event          creation_date (datetime): Date and time of the event creation.      \"\"\"        entity_type: EventEntityType      operation: EventOperation      entity_id: Optional[str] = None      attribute_name: Optional[str] = None      attribute_value: Optional[Any] = None        metadata: dict = field(default_factory=dict)      creation_date: datetime = field(init=False)        def __post_init__(self):          # Creation date          super().__setattr__(\"creation_date\", datetime.now())            # Check operation:          if self.entity_type in _UNSUBMITTABLE_ENTITY_TYPES and self.operation == EventOperation.SUBMISSION:              raise InvalidEventOperation            # Check attribute name:          if self.operation in _NO_ATTRIBUTE_NAME_OPERATIONS and self.attribute_name is not None:              raise InvalidEventAttributeName      @singledispatch  def _make_event(      entity: Any,      operation: EventOperation,      /,      attribute_name: Optional[str] = None,      attribute_value: Optional[Any] = None,      **kwargs,  ) -> Event:      \"\"\"Helper function to make an event for this entity with the given `EventOperation^` type.      In case of `EventOperation.UPDATE^` events, an attribute name and value must be given.        Parameters:          entity (Any): The entity object to generate an event for.          operation (EventOperation^): The operation of the event. The possible values are:              <ul>                  <li>CREATION</li>                  <li>UPDATE</li>                  <li>DELETION</li>                  <li>SUBMISSION</li>              </ul>          attribute_name (Optional[str]): The name of the updated attribute for a `EventOperation.UPDATE`.              This argument is always given in case of an UPDATE.          attribute_value (Optional[Any]): The value of the udated attribute for a `EventOperation.UPDATE`.              This argument is always given in case of an UPDATE.          **kwargs (dict[str, any]): Any extra information that would be passed to the metadata event.              Note: you should pass only simple types: str, float, double as values.\"\"\"      raise Exception(f\"Unexpected entity type: {type(entity)}\") "}
{"text": "\"\"\"  Package for notifications about changes on `Core^` service entities.      The Core service generates `Event^` objects to track changes on entities.  These events are then relayed to a `Notifier^`, which handles the dispatch  to consumers interested in specific event topics.    To subscribe, a consumer needs to invoke the `Notifier.register()^` method.  This call will yield a `RegistrationId^` and a dedicated event queue for  receiving notifications.    To handle notifications, an event consumer (e.g., the `CoreEventConsumerBase^`  object) must be instantiated with an associated event queue.  \"\"\"    from ._registration import _Registration  from ._topic import _Topic  from .core_event_consumer import CoreEventConsumerBase  from .event import _ENTITY_TO_EVENT_ENTITY_TYPE, Event, EventEntityType, EventOperation, _make_event  from .notifier import Notifier, _publish_event  from .registration_id import RegistrationId "}
{"text": "from typing import NewType    RegistrationId = NewType(\"RegistrationId\", str)  RegistrationId.__doc__ = \"\"\"Registration identifier. It can be used to instantiate a `CoreEventConsumerBase^`.\"\"\" "}
{"text": "from queue import SimpleQueue  from typing import Optional  from uuid import uuid4    from ._topic import _Topic  from .event import EventEntityType, EventOperation  from .registration_id import RegistrationId      class _Registration:        _ID_PREFIX = \"REGISTRATION\"      __SEPARATOR = \"_\"        def __init__(          self,          entity_type: Optional[EventEntityType] = None,          entity_id: Optional[str] = None,          operation: Optional[EventOperation] = None,          attribute_name: Optional[str] = None,      ):            self.registration_id: str = self._new_id()          self.topic: _Topic = _Topic(entity_type, entity_id, operation, attribute_name)          self.queue: SimpleQueue = SimpleQueue()        @staticmethod      def _new_id() -> RegistrationId:          \"\"\"Generate a unique registration identifier.\"\"\"          return RegistrationId(_Registration.__SEPARATOR.join([_Registration._ID_PREFIX, str(uuid4())]))        def __hash__(self) -> int:          return hash(self.registration_id) "}
{"text": "from typing import Optional    from ..exceptions.exceptions import InvalidEventOperation  from .event import _UNSUBMITTABLE_ENTITY_TYPES, EventEntityType, EventOperation      class _Topic:      def __init__(          self,          entity_type: Optional[EventEntityType] = None,          entity_id: Optional[str] = None,          operation: Optional[EventOperation] = None,          attribute_name: Optional[str] = None,      ):            self.entity_type = entity_type          self.entity_id = entity_id          self.operation = self.__preprocess_operation(operation, self.entity_type)          self.attribute_name = self.__preprocess_attribute_name(attribute_name, self.operation)        @classmethod      def __preprocess_attribute_name(          cls, attribute_name: Optional[str] = None, operation: Optional[EventOperation] = None      ) -> Optional[str]:            # if operation in _NO_ATTRIBUTE_NAME_OPERATIONS and attribute_name is not None:          #     raise InvalidEventAttributeName          return attribute_name        @classmethod      def __preprocess_operation(          cls, operation: Optional[EventOperation] = None, entity_type: Optional[EventEntityType] = None      ) -> Optional[EventOperation]:          if (              entity_type              and operation              and entity_type in _UNSUBMITTABLE_ENTITY_TYPES              and operation == EventOperation.SUBMISSION          ):              raise InvalidEventOperation          return operation        def __hash__(self):          return hash((self.entity_type, self.entity_id, self.operation, self.attribute_name))        def __eq__(self, __value) -> bool:          if (              self.entity_type == __value.entity_type              and self.entity_id == __value.entity_id              and self.operation == __value.operation              and self.attribute_name == __value.attribute_name          ):              return True          return False "}
{"text": "import abc  import threading  from queue import Empty, SimpleQueue    from .event import Event      class CoreEventConsumerBase(threading.Thread):      \"\"\"Abstract base class for implementing a Core event consumer.        This class provides a framework for consuming events from a queue in a separate thread.      It should be subclassed, and the `process_event` method should be implemented to define      the custom logic for handling incoming events.        Example usage:        ```python      class MyEventConsumer(CoreEventConsumerBase):          def process_event(self, event: Event):              # Custom event processing logic here              print(f\"Received event created at : {event.creation_date}\")              pass        consumer = MyEventConsumer(\"consumer_1\", event_queue)      consumer.start()      # ...      consumer.stop()      ```        Subclasses should implement the `process_event` method to define their specific event handling behavior.        Attributes:          queue (SimpleQueue): The queue from which events will be consumed.          \"\"\"        def __init__(self, registration_id: str, queue: SimpleQueue):          \"\"\"Initialize a CoreEventConsumerBase instance.            Parameters:              registration_id (str): A unique identifier of the registration. You can get a                  registration id invoking `Notifier.register()^` method.              queue (SimpleQueue): The queue from which events will be consumed. You can get a                  queue invoking `Notifier.register()^` method.          \"\"\"          threading.Thread.__init__(self, name=f\"Thread-Taipy-Core-Consumer-{registration_id}\")          self.daemon = True          self.queue = queue          self.__STOP_FLAG = False          self._TIMEOUT = 0.1        def start(self):          \"\"\"Start the event consumer thread.\"\"\"          self.__STOP_FLAG = False          threading.Thread.start(self)        def stop(self):          \"\"\"Stop the event consumer thread.\"\"\"          self.__STOP_FLAG = True        def run(self):          while not self.__STOP_FLAG:              try:                  event: Event = self.queue.get(block=True, timeout=self._TIMEOUT)                  self.process_event(event)              except Empty:                  pass        @abc.abstractmethod      def process_event(self, event: Event):          \"\"\"This method should be overridden in subclasses to define how events are processed.\"\"\"          raise NotImplementedError "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._filesystem_repository import _FileSystemRepository  from ._cycle_converter import _CycleConverter  from ._cycle_model import _CycleModel      class _CycleFSRepository(_FileSystemRepository):      def __init__(self):          super().__init__(model_type=_CycleModel, converter=_CycleConverter, dir_name=\"cycles\") "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._sql_repository import _SQLRepository  from ._cycle_converter import _CycleConverter  from ._cycle_model import _CycleModel      class _CycleSQLRepository(_SQLRepository):      def __init__(self):          super().__init__(model_type=_CycleModel, converter=_CycleConverter) "}
{"text": "from typing import NewType    CycleId = NewType(\"CycleId\", str)  CycleId.__doc__ = \"\"\"Type that holds a `Cycle^` identifier.\"\"\" "}
{"text": "from dataclasses import dataclass  from typing import Any, Dict    from sqlalchemy import JSON, Column, Enum, String, Table    from taipy.config.common.frequency import Frequency    from .._repository._base_taipy_model import _BaseModel  from .._repository.db._sql_base_model import mapper_registry  from .cycle_id import CycleId      @mapper_registry.mapped  @dataclass  class _CycleModel(_BaseModel):      __table__ = Table(          \"cycle\",          mapper_registry.metadata,          Column(\"id\", String, primary_key=True),          Column(\"name\", String),          Column(\"frequency\", Enum(Frequency)),          Column(\"properties\", JSON),          Column(\"creation_date\", String),          Column(\"start_date\", String),          Column(\"end_date\", String),      )      id: CycleId      name: str      frequency: Frequency      properties: Dict[str, Any]      creation_date: str      start_date: str      end_date: str        @staticmethod      def from_dict(data: Dict[str, Any]):          return _CycleModel(              id=data[\"id\"],              name=data[\"name\"],              frequency=Frequency._from_repr(data[\"frequency\"]),              properties=_BaseModel._deserialize_attribute(data[\"properties\"]),              creation_date=data[\"creation_date\"],              start_date=data[\"start_date\"],              end_date=data[\"end_date\"],          )        def to_list(self):          return [              self.id,              self.name,              repr(self.frequency),              _BaseModel._serialize_attribute(self.properties),              self.creation_date,              self.start_date,              self.end_date,          ] "}
{"text": "from datetime import datetime    from .._repository._abstract_converter import _AbstractConverter  from ..cycle._cycle_model import _CycleModel  from ..cycle.cycle import Cycle      class _CycleConverter(_AbstractConverter):      @classmethod      def _entity_to_model(cls, cycle: Cycle) -> _CycleModel:          return _CycleModel(              id=cycle.id,              name=cycle._name,              frequency=cycle._frequency,              creation_date=cycle._creation_date.isoformat(),              start_date=cycle._start_date.isoformat(),              end_date=cycle._end_date.isoformat(),              properties=cycle._properties.data,          )        @classmethod      def _model_to_entity(cls, model: _CycleModel) -> Cycle:          return Cycle(              id=model.id,              name=model.name,              frequency=model.frequency,              properties=model.properties,              creation_date=datetime.fromisoformat(model.creation_date),              start_date=datetime.fromisoformat(model.start_date),              end_date=datetime.fromisoformat(model.end_date),          ) "}
{"text": "from typing import Type    from .._manager._manager_factory import _ManagerFactory  from ..common._utils import _load_fct  from ..cycle._cycle_manager import _CycleManager  from ._cycle_fs_repository import _CycleFSRepository  from ._cycle_sql_repository import _CycleSQLRepository      class _CycleManagerFactory(_ManagerFactory):        __REPOSITORY_MAP = {\"default\": _CycleFSRepository, \"sql\": _CycleSQLRepository}        @classmethod      def _build_manager(cls) -> Type[_CycleManager]:  # type: ignore          if cls._using_enterprise():              cycle_manager = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".cycle._cycle_manager\", \"_CycleManager\"              )  # type: ignore              build_repository = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".cycle._cycle_manager_factory\", \"_CycleManagerFactory\"              )._build_repository  # type: ignore          else:              cycle_manager = _CycleManager              build_repository = cls._build_repository          cycle_manager._repository = build_repository()  # type: ignore          return cycle_manager  # type: ignore        @classmethod      def _build_repository(cls):          return cls._get_repository_with_repo_map(cls.__REPOSITORY_MAP)() "}
{"text": "from abc import abstractmethod  from importlib import util  from typing import Type    from taipy.config import Config    from ._manager import _Manager      class _ManagerFactory:      _TAIPY_ENTERPRISE_MODULE = \"taipy.enterprise\"      _TAIPY_ENTERPRISE_CORE_MODULE = _TAIPY_ENTERPRISE_MODULE + \".core\"        @classmethod      @abstractmethod      def _build_manager(cls) -> Type[_Manager]:  # type: ignore          raise NotImplementedError        @classmethod      def _build_repository(cls):          raise NotImplementedError        @classmethod      def _using_enterprise(cls) -> bool:          return util.find_spec(cls._TAIPY_ENTERPRISE_MODULE) is not None        @staticmethod      def _get_repository_with_repo_map(repository_map: dict):          return repository_map.get(Config.core.repository_type, repository_map.get(\"default\")) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import pathlib  from importlib import metadata  from typing import Dict, Generic, Iterable, List, Optional, TypeVar, Union    from taipy.logger._taipy_logger import _TaipyLogger    from .._entity._entity_ids import _EntityIds  from .._repository._abstract_repository import _AbstractRepository  from ..exceptions.exceptions import ModelNotFound  from ..notification import Event, EventOperation, Notifier    EntityType = TypeVar(\"EntityType\")      class _Manager(Generic[EntityType]):      _repository: _AbstractRepository      _logger = _TaipyLogger._get_logger()      _ENTITY_NAME: str = \"Entity\"        @classmethod      def _delete_all(cls):          \"\"\"          Deletes all entities.          \"\"\"          cls._repository._delete_all()          if hasattr(cls, \"_EVENT_ENTITY_TYPE\"):              Notifier.publish(                  Event(                      cls._EVENT_ENTITY_TYPE,                      EventOperation.DELETION,                      metadata={\"delete_all\": True},                  )              )        @classmethod      def _delete_many(cls, ids: Iterable):          \"\"\"          Deletes entities by a list of ids.          \"\"\"          cls._repository._delete_many(ids)          if hasattr(cls, \"_EVENT_ENTITY_TYPE\"):              for entity_id in ids:                  Notifier.publish(                      Event(                          cls._EVENT_ENTITY_TYPE,  # type: ignore                          EventOperation.DELETION,                          entity_id=entity_id,                          metadata={\"delete_all\": True},                      )                  )        @classmethod      def _delete_by_version(cls, version_number: str):          \"\"\"          Deletes entities by version number.          \"\"\"          cls._repository._delete_by(attribute=\"version\", value=version_number)          if hasattr(cls, \"_EVENT_ENTITY_TYPE\"):              Notifier.publish(                  Event(                      cls._EVENT_ENTITY_TYPE,  # type: ignore                      EventOperation.DELETION,                      metadata={\"delete_by_version\": version_number},                  )              )        @classmethod      def _delete(cls, id):          \"\"\"          Deletes an entity by id.          \"\"\"          cls._repository._delete(id)          if hasattr(cls, \"_EVENT_ENTITY_TYPE\"):              Notifier.publish(                  Event(                      cls._EVENT_ENTITY_TYPE,                      EventOperation.DELETION,                      entity_id=id,                  )              )        @classmethod      def _set(cls, entity: EntityType):          \"\"\"          Save or update an entity.          \"\"\"          cls._repository._save(entity)        @classmethod      def _get_all(cls, version_number: Optional[str] = \"all\") -> List[EntityType]:          \"\"\"          Returns all entities.          \"\"\"          filters: List[Dict] = []          return cls._repository._load_all(filters)        @classmethod      def _get_all_by(cls, filters: Optional[List[Dict]] = None) -> List[EntityType]:          \"\"\"          Returns all entities based on a criteria.          \"\"\"          if not filters:              filters = []          return cls._repository._load_all(filters)        @classmethod      def _get(cls, entity: Union[str, EntityType], default=None) -> EntityType:          \"\"\"          Returns an entity by id or reference.          \"\"\"          entity_id = entity if isinstance(entity, str) else entity.id  # type: ignore          try:              return cls._repository._load(entity_id)          except ModelNotFound:              cls._logger.error(f\"{cls._ENTITY_NAME} not found: {entity_id}\")              return default        @classmethod      def _exists(cls, entity_id: str) -> bool:          \"\"\"          Returns True if the entity id exists.          \"\"\"          return cls._repository._exists(entity_id)        @classmethod      def _delete_entities_of_multiple_types(cls, _entity_ids: _EntityIds):          \"\"\"          Deletes entities of multiple types.          \"\"\"          from ..cycle._cycle_manager_factory import _CycleManagerFactory          from ..data._data_manager_factory import _DataManagerFactory          from ..job._job_manager_factory import _JobManagerFactory          from ..scenario._scenario_manager_factory import _ScenarioManagerFactory          from ..sequence._sequence_manager_factory import _SequenceManagerFactory          from ..submission._submission_manager_factory import _SubmissionManagerFactory          from ..task._task_manager_factory import _TaskManagerFactory            _CycleManagerFactory._build_manager()._delete_many(_entity_ids.cycle_ids)          _SequenceManagerFactory._build_manager()._delete_many(_entity_ids.sequence_ids)          _ScenarioManagerFactory._build_manager()._delete_many(_entity_ids.scenario_ids)          _TaskManagerFactory._build_manager()._delete_many(_entity_ids.task_ids)          _JobManagerFactory._build_manager()._delete_many(_entity_ids.job_ids)          _DataManagerFactory._build_manager()._delete_many(_entity_ids.data_node_ids)          _SubmissionManagerFactory._build_manager()._delete_many(_entity_ids.submission_ids)        @classmethod      def _export(cls, id: str, folder_path: Union[str, pathlib.Path]):          \"\"\"          Export an entity.          \"\"\"          return cls._repository._export(id, folder_path)        @classmethod      def _is_editable(cls, entity: Union[EntityType, _EntityIds]) -> bool:          return True        @classmethod      def _is_readable(cls, entity: Union[EntityType, _EntityIds]) -> bool:          return True "}
{"text": "from datetime import datetime  from typing import Any    from taipy.config import Config  from taipy.config._config import _Config    from .._entity._entity import _Entity      class _Version(_Entity):      def __init__(self, id: str, config: Any) -> None:          self.id: str = id          self.config: _Config = config          self.creation_date: datetime = datetime.now()        def __eq__(self, other):          return self.id == other.id and self.__is_config_eq(other)        def __is_config_eq(self, other):          return Config._serializer._str(self.config) == Config._serializer._str(other.config) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from typing import Dict, List    from .._version._version_manager_factory import _VersionManagerFactory      class _VersionMixin:        _version_manager = _VersionManagerFactory._build_manager()        @classmethod      def __fetch_version_number(cls, version_number):          version_number = _VersionManagerFactory._build_manager()._replace_version_number(version_number)            if not isinstance(version_number, List):              version_number = [version_number] if version_number else []          return version_number        @classmethod      def _build_filters_with_version(cls, version_number) -> List[Dict]:          filters = []          if versions := cls.__fetch_version_number(version_number):              filters = [{\"version\": version} for version in versions]          return filters        @classmethod      def _get_latest_version(cls):          return cls._version_manager._get_latest_version() "}
{"text": "from .._manager._manager_factory import _ManagerFactory  from ..common import _utils  from ._version_fs_repository import _VersionFSRepository  from ._version_manager import _VersionManager  from ._version_sql_repository import _VersionSQLRepository      class _VersionManagerFactory(_ManagerFactory):        __REPOSITORY_MAP = {\"default\": _VersionFSRepository, \"sql\": _VersionSQLRepository}        @classmethod      def _build_manager(cls) -> _VersionManager:  # type: ignore          if cls._using_enterprise():              version_manager = _utils._load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \"._version._version_manager\", \"_VersionManager\"              )  # type: ignore              build_repository = _utils._load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \"._version._version_manager_factory\", \"_VersionManagerFactory\"              )._build_repository  # type: ignore          else:              version_manager = _VersionManager              build_repository = cls._build_repository          version_manager._repository = build_repository()  # type: ignore          return version_manager  # type: ignore        @classmethod      def _build_repository(cls):          return cls._get_repository_with_repo_map(cls.__REPOSITORY_MAP)() "}
{"text": "from abc import ABC, abstractmethod      class _VersionRepositoryInterface(ABC):      _LATEST_VERSION_KEY = \"latest_version\"      _DEVELOPMENT_VERSION_KEY = \"development_version\"      _PRODUCTION_VERSION_KEY = \"production_version\"        @abstractmethod      def _set_latest_version(self, version_number):          raise NotImplementedError        @abstractmethod      def _get_latest_version(self):          raise NotImplementedError        @abstractmethod      def _set_development_version(self, version_number):          raise NotImplementedError        @abstractmethod      def _get_development_version(self):          raise NotImplementedError        @abstractmethod      def _set_production_version(self, version_number):          raise NotImplementedError        @abstractmethod      def _get_production_versions(self):          raise NotImplementedError        @abstractmethod      def _delete_production_version(self, version_number):          raise NotImplementedError "}
{"text": "import json  from typing import List    from taipy.logger._taipy_logger import _TaipyLogger    from .._repository._filesystem_repository import _FileSystemRepository  from ..exceptions.exceptions import VersionIsNotProductionVersion  from ._version_converter import _VersionConverter  from ._version_model import _VersionModel  from ._version_repository_interface import _VersionRepositoryInterface      class _VersionFSRepository(_FileSystemRepository, _VersionRepositoryInterface):      def __init__(self):          super().__init__(model_type=_VersionModel, converter=_VersionConverter, dir_name=\"version\")        @property      def _version_file_path(self):          return super()._storage_folder / \"version.json\"        def _delete_all(self):          super()._delete_all()            if self._version_file_path.exists():              self._version_file_path.unlink()        def _set_latest_version(self, version_number):          if self._version_file_path.exists():              with open(self._version_file_path, \"r\") as f:                  file_content = json.load(f)              file_content[self._LATEST_VERSION_KEY] = version_number          else:              self.dir_path.mkdir(parents=True, exist_ok=True)              file_content = {                  self._LATEST_VERSION_KEY: version_number,                  self._DEVELOPMENT_VERSION_KEY: \"\",                  self._PRODUCTION_VERSION_KEY: [],              }          self._version_file_path.write_text(              json.dumps(                  file_content,                  ensure_ascii=False,                  indent=0,              )          )        def _get_latest_version(self) -> str:          with open(self._version_file_path, \"r\") as f:              file_content = json.load(f)          return file_content[self._LATEST_VERSION_KEY]        def _set_development_version(self, version_number):          if self._version_file_path.exists():              with open(self._version_file_path, \"r\") as f:                  file_content = json.load(f)                file_content[self._DEVELOPMENT_VERSION_KEY] = version_number              file_content[self._LATEST_VERSION_KEY] = version_number          else:              self.dir_path.mkdir(parents=True, exist_ok=True)              file_content = {                  self._LATEST_VERSION_KEY: version_number,                  self._DEVELOPMENT_VERSION_KEY: version_number,                  self._PRODUCTION_VERSION_KEY: [],              }          self._version_file_path.write_text(              json.dumps(                  file_content,                  ensure_ascii=False,                  indent=0,              )          )        def _get_development_version(self) -> str:          with open(self._version_file_path, \"r\") as f:              file_content = json.load(f)          return file_content[self._DEVELOPMENT_VERSION_KEY]        def _set_production_version(self, version_number):          if self._version_file_path.exists():              with open(self._version_file_path, \"r\") as f:                  file_content = json.load(f)              file_content[self._LATEST_VERSION_KEY] = version_number              if version_number not in file_content[self._PRODUCTION_VERSION_KEY]:                  file_content[self._PRODUCTION_VERSION_KEY].append(version_number)              else:                  _TaipyLogger._get_logger().info(f\"Version {version_number} is already a production version.\")          else:              self.dir_path.mkdir(parents=True, exist_ok=True)              file_content = {                  self._LATEST_VERSION_KEY: version_number,                  self._DEVELOPMENT_VERSION_KEY: \"\",                  self._PRODUCTION_VERSION_KEY: [version_number],              }          self._version_file_path.write_text(              json.dumps(                  file_content,                  ensure_ascii=False,                  indent=0,              )          )        def _get_production_versions(self) -> List[str]:          with open(self._version_file_path, \"r\") as f:              file_content = json.load(f)          return file_content[self._PRODUCTION_VERSION_KEY]        def _delete_production_version(self, version_number):          try:              with open(self._version_file_path, \"r\") as f:                  file_content = json.load(f)              if version_number not in file_content[self._PRODUCTION_VERSION_KEY]:                  raise VersionIsNotProductionVersion(f\"Version '{version_number}' is not a production version.\")              file_content[self._PRODUCTION_VERSION_KEY].remove(version_number)              self._version_file_path.write_text(                  json.dumps(                      file_content,                      ensure_ascii=False,                      indent=0,                  )              )          except FileNotFoundError:              raise VersionIsNotProductionVersion(f\"Version '{version_number}' is not a production version.\") "}
{"text": "from sqlalchemy.dialects import sqlite    from .._repository._sql_repository import _SQLRepository  from ..exceptions.exceptions import ModelNotFound, VersionIsNotProductionVersion  from ._version_converter import _VersionConverter  from ._version_model import _VersionModel  from ._version_repository_interface import _VersionRepositoryInterface      class _VersionSQLRepository(_SQLRepository, _VersionRepositoryInterface):      def __init__(self):          super().__init__(model_type=_VersionModel, converter=_VersionConverter)        def _set_latest_version(self, version_number):          if old_latest := self.db.execute(str(self.table.select().filter_by(is_latest=True))).fetchone():              old_latest = self.model_type.from_dict(old_latest)              old_latest.is_latest = False              self._update_entry(old_latest)            version = self.__get_by_id(version_number)          version.is_latest = True          self._update_entry(version)        def _get_latest_version(self):          if latest := self.db.execute(              str(self.table.select().filter_by(is_latest=True).compile(dialect=sqlite.dialect()))          ).fetchone():              return latest[\"id\"]          raise ModelNotFound(self.model_type, \"\")        def _set_development_version(self, version_number):          if old_development := self.db.execute(str(self.table.select().filter_by(is_development=True))).fetchone():              old_development = self.model_type.from_dict(old_development)              old_development.is_development = False              self._update_entry(old_development)            version = self.__get_by_id(version_number)          version.is_development = True          self._update_entry(version)            self._set_latest_version(version_number)        def _get_development_version(self):          if development := self.db.execute(str(self.table.select().filter_by(is_development=True))).fetchone():              return development[\"id\"]          raise ModelNotFound(self.model_type, \"\")        def _set_production_version(self, version_number):          version = self.__get_by_id(version_number)          version.is_production = True          self._update_entry(version)            self._set_latest_version(version_number)        def _get_production_versions(self):          if productions := self.db.execute(              str(self.table.select().filter_by(is_production=True).compile(dialect=sqlite.dialect())),          ).fetchall():              return [p[\"id\"] for p in productions]          return []        def _delete_production_version(self, version_number):          version = self.__get_by_id(version_number)            if not version or not version.is_production:              raise VersionIsNotProductionVersion(f\"Version '{version_number}' is not a production version.\")          version.is_production = False          self._update_entry(version)        def __get_by_id(self, version_id):          query = str(self.table.select().filter_by(id=version_id).compile(dialect=sqlite.dialect()))          entry = self.db.execute(query, [version_id]).fetchone()          return self.model_type.from_dict(entry) if entry else None "}
{"text": "from datetime import datetime    from taipy.config import Config    from .._repository._abstract_converter import _AbstractConverter  from .._version._version import _Version  from .._version._version_model import _VersionModel      class _VersionConverter(_AbstractConverter):      @classmethod      def _entity_to_model(cls, version: _Version) -> _VersionModel:          return _VersionModel(              id=version.id, config=Config._to_json(version.config), creation_date=version.creation_date.isoformat()          )        @classmethod      def _model_to_entity(cls, model: _VersionModel) -> _Version:          version = _Version(id=model.id, config=Config._from_json(model.config))          version.creation_date = datetime.fromisoformat(model.creation_date)          return version "}
{"text": "from dataclasses import dataclass  from typing import Any, Dict    from sqlalchemy import Boolean, Column, String, Table    from .._repository._base_taipy_model import _BaseModel  from .._repository.db._sql_base_model import mapper_registry      @mapper_registry.mapped  @dataclass  class _VersionModel(_BaseModel):      __table__ = Table(          \"version\",          mapper_registry.metadata,          Column(\"id\", String, primary_key=True),          Column(\"config\", String),  # config is store as a json string          Column(\"creation_date\", String),          Column(\"is_production\", Boolean),          Column(\"is_development\", Boolean),          Column(\"is_latest\", Boolean),      )      id: str      config: Dict[str, Any]      creation_date: str        @staticmethod      def from_dict(data: Dict[str, Any]):          model = _VersionModel(              id=data[\"id\"],              config=data[\"config\"],              creation_date=data[\"creation_date\"],          )          model.is_production = data.get(\"is_production\")  # type: ignore          model.is_development = data.get(\"is_development\")  # type: ignore          model.is_latest = data.get(\"is_latest\")  # type: ignore          return model        def to_list(self):          return [              self.id,              self.config,              self.creation_date,              self.is_production,              self.is_development,              self.is_latest,          ] "}
{"text": "from typing import Callable, List    from taipy.config.config import Config    from .._entity._reload import _Reloader  from ..config import MigrationConfig  from ._version_manager_factory import _VersionManagerFactory      def _migrate_entity(entity):      if (          latest_version := _VersionManagerFactory._build_manager()._get_latest_version()      ) in _VersionManagerFactory._build_manager()._get_production_versions():          if migration_fcts := __get_migration_fcts_to_latest(entity._version, entity.config_id):              with _Reloader():                  for fct in migration_fcts:                      entity = fct(entity)                  entity._version = latest_version        return entity      def __get_migration_fcts_to_latest(source_version: str, config_id: str) -> List[Callable]:      migration_fcts_to_latest: List[Callable] = []        production_versions = _VersionManagerFactory._build_manager()._get_production_versions()      try:          start_index = production_versions.index(source_version) + 1      except ValueError:          return migration_fcts_to_latest        versions_to_migrate = production_versions[start_index:]        for version in versions_to_migrate:          migration_fct = Config.unique_sections[MigrationConfig.name].migration_fcts.get(version, {}).get(config_id)          if migration_fct:              migration_fcts_to_latest.append(migration_fct)        return migration_fcts_to_latest "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import os  import sys      def _vt_codes_enabled_in_windows_registry():      \"\"\"      Check the Windows Registry to see if VT code handling has been enabled      by default, see https://superuser.com/a/1300251/447564.      \"\"\"      try:          # winreg is only available on Windows.          import winreg      except ImportError:          return False      else:          try:              reg_key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, \"Console\")              reg_key_value, _ = winreg.QueryValueEx(reg_key, \"VirtualTerminalLevel\")          except FileNotFoundError:              return False          else:              return reg_key_value == 1      def _is_color_supported():      \"\"\"      Return True if the running system's terminal supports color,      and False otherwise.      \"\"\"        is_a_tty = hasattr(sys.stdout, \"isatty\") and sys.stdout.isatty()        return is_a_tty and (          sys.platform != \"win32\"          or \"ANSICON\" in os.environ          or \"WT_SESSION\" in os.environ  # Windows Terminal supports VT codes.          or os.environ.get(\"TERM_PROGRAM\") == \"vscode\"  # VSCode's built-in terminal supports colors.          or _vt_codes_enabled_in_windows_registry()      )      class _Bcolors:      PURPLE = \"\\033[95m\" if _is_color_supported() else \"\"      BLUE = \"\\033[94m\" if _is_color_supported() else \"\"      CYAN = \"\\033[96m\" if _is_color_supported() else \"\"      GREEN = \"\\033[92m\" if _is_color_supported() else \"\"      BOLD = \"\\033[1m\" if _is_color_supported() else \"\"      UNDERLINE = \"\\033[4m\" if _is_color_supported() else \"\"      END = \"\\033[0m\" if _is_color_supported() else \"\" "}
{"text": "from .exceptions import * "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from __future__ import annotations    import abc  from typing import Any, Callable, List, Optional, Set, Union    import networkx as nx    from ..common._listattributes import _ListAttributes  from ..common._utils import _Subscriber  from ..data.data_node import DataNode  from ..job.job import Job  from ..task.task import Task  from ._dag import _DAG      class Submittable:      \"\"\"Instance of an entity that can be submitted for execution.        A submittable holds functions that can be used to build the execution directed acyclic graph.        Attributes:          subscribers (List[Callable]): The list of callbacks to be called on `Job^`'s status change.      \"\"\"        def __init__(self, subscribers: Optional[List[_Subscriber]] = None):          self._subscribers = _ListAttributes(self, subscribers or list())        @abc.abstractmethod      def submit(          self,          callbacks: Optional[List[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,      ):          raise NotImplementedError        def get_inputs(self) -> Set[DataNode]:          \"\"\"Return the set of input data nodes of the submittable entity.            Returns:              The set of input data nodes.          \"\"\"          dag = self._build_dag()          return self.__get_inputs(dag)        def __get_inputs(self, dag: nx.DiGraph) -> Set[DataNode]:          return {node for node, degree in dict(dag.in_degree).items() if degree == 0 and isinstance(node, DataNode)}        def get_outputs(self) -> Set[DataNode]:          \"\"\"Return the set of output data nodes of the submittable entity.            Returns:              The set of output data nodes.          \"\"\"          dag = self._build_dag()          return self.__get_outputs(dag)        def __get_outputs(self, dag: nx.DiGraph) -> set[DataNode]:          return {node for node, degree in dict(dag.out_degree).items() if degree == 0 and isinstance(node, DataNode)}        def get_intermediate(self) -> Set[DataNode]:          \"\"\"Return the set of intermediate data nodes of the submittable entity.            Returns:              The set of intermediate data nodes.          \"\"\"          dag = self._build_dag()          all_data_nodes_in_dag = {node for node in dag.nodes if isinstance(node, DataNode)}          return all_data_nodes_in_dag - self.__get_inputs(dag) - self.__get_outputs(dag)        def is_ready_to_run(self) -> bool:          \"\"\"Indicate if the entity is ready to be run.            Returns:              True if the given entity is ready to be run. False otherwise.          \"\"\"          return all(dn.is_ready_for_reading for dn in self.get_inputs())        def data_nodes_being_edited(self) -> Set[DataNode]:          \"\"\"Return the set of data nodes of the submittable entity that are being edited.            Returns:              The set of data nodes that are being edited.          \"\"\"          dag = self._build_dag()          return {node for node in dag.nodes if isinstance(node, DataNode) and node.edit_in_progress}        @abc.abstractmethod      def subscribe(self, callback: Callable[[Submittable, Job], None], params: Optional[List[Any]] = None):          raise NotImplementedError        @abc.abstractmethod      def unsubscribe(self, callback: Callable[[Submittable, Job], None], params: Optional[List[Any]] = None):          raise NotImplementedError        @abc.abstractmethod      def _get_set_of_tasks(self) -> Set[Task]:          raise NotImplementedError        def _get_dag(self) -> _DAG:          return _DAG(self._build_dag())        def _build_dag(self) -> nx.DiGraph:          graph = nx.DiGraph()          tasks = self._get_set_of_tasks()          for task in tasks:              if has_input := task.input:                  for predecessor in task.input.values():                      graph.add_edges_from([(predecessor, task)])              if has_output := task.output:                  for successor in task.output.values():                      graph.add_edges_from([(task, successor)])              if not has_input and not has_output:                  graph.add_node(task)          return graph        def _get_sorted_tasks(self) -> List[List[Task]]:          dag = self._build_dag()          remove = [node for node, degree in dict(dag.in_degree).items() if degree == 0 and isinstance(node, DataNode)]          dag.remove_nodes_from(remove)          return list(nodes for nodes in nx.topological_generations(dag) if (Task in (type(node) for node in nodes)))        def _add_subscriber(self, callback: Callable, params: Optional[List[Any]] = None):          params = [] if params is None else params          self._subscribers.append(_Subscriber(callback=callback, params=params))        def _remove_subscriber(self, callback: Callable, params: Optional[List[Any]] = None):          if params is not None:              self._subscribers.remove(_Subscriber(callback, params))          else:              elem = [x for x in self._subscribers if x.callback == callback]              if not elem:                  raise ValueError              self._subscribers.remove(elem[0]) "}
{"text": "from typing import List    from .._entity._reload import _get_manager  from ..notification import Notifier      class _Entity:      _MANAGER_NAME: str      _is_in_context = False      _in_context_attributes_changed_collector: List        def __enter__(self):          self._is_in_context = True          self._in_context_attributes_changed_collector = list()          return self        def __exit__(self, exc_type, exc_value, exc_traceback):          # If multiple entities is in context, the last to enter will be the first to exit          self._is_in_context = False          if hasattr(self, \"_properties\"):              for to_delete_key in self._properties._pending_deletions:                  self._properties.data.pop(to_delete_key, None)              self._properties.data.update(self._properties._pending_changes)          _get_manager(self._MANAGER_NAME)._set(self)            for event in self._in_context_attributes_changed_collector:              Notifier.publish(event)          _get_manager(self._MANAGER_NAME)._set(self) "}
{"text": "from collections import UserDict    from ..notification import _ENTITY_TO_EVENT_ENTITY_TYPE, EventOperation, Notifier, _make_event      class _Properties(UserDict):      __PROPERTIES_ATTRIBUTE_NAME = \"properties\"        def __init__(self, entity_owner, **kwargs):          super().__init__(**kwargs)          self._entity_owner = entity_owner          self._pending_changes = {}          self._pending_deletions = set()        def __setitem__(self, key, value):          super(_Properties, self).__setitem__(key, value)          from ... import core as tp            if hasattr(self, \"_entity_owner\"):              event = _make_event(                  self._entity_owner,                  EventOperation.UPDATE,                  attribute_name=self.__PROPERTIES_ATTRIBUTE_NAME,                  attribute_value=value,              )              if not self._entity_owner._is_in_context:                  tp.set(self._entity_owner)                  Notifier.publish(event)              else:                  if key in self._pending_deletions:                      self._pending_deletions.remove(key)                  self._pending_changes[key] = value                  self._entity_owner._in_context_attributes_changed_collector.append(event)        def __getitem__(self, key):          from taipy.config.common._template_handler import _TemplateHandler as _tpl            return _tpl._replace_templates(super(_Properties, self).__getitem__(key))        def __delitem__(self, key):          super(_Properties, self).__delitem__(key)          from ... import core as tp            if hasattr(self, \"_entity_owner\"):              event = _make_event(                  self._entity_owner,                  EventOperation.UPDATE,                  attribute_name=self.__PROPERTIES_ATTRIBUTE_NAME,                  attribute_value=None,              )              if not self._entity_owner._is_in_context:                  tp.set(self._entity_owner)                  Notifier.publish(event)              else:                  self._pending_changes.pop(key, None)                  self._pending_deletions.add(key)                  self._entity_owner._in_context_attributes_changed_collector.append(event) "}
{"text": "from __future__ import annotations      class _EntityIds:      def __init__(self):          self.data_node_ids = set()          self.task_ids = set()          self.scenario_ids = set()          self.sequence_ids = set()          self.job_ids = set()          self.cycle_ids = set()          self.submission_ids = set()        def __add__(self, other: _EntityIds):          self.data_node_ids.update(other.data_node_ids)          self.task_ids.update(other.task_ids)          self.scenario_ids.update(other.scenario_ids)          self.sequence_ids.update(other.sequence_ids)          self.job_ids.update(other.job_ids)          self.cycle_ids.update(other.cycle_ids)          self.submission_ids.update(other.submission_ids)          return self        def __iadd__(self, other: _EntityIds):          self.__add__(other)          return self "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  import math  from functools import reduce  from typing import Any, Dict, List, Tuple    import networkx as nx      class _Node:      def __init__(self, entity: Any, x, y):          self.type = entity.__class__.__name__          self.entity = entity          self.x = x          self.y = y      class _Edge:      def __init__(self, src: _Node, dest: _Node):          self.src = src          self.dest = dest      class _DAG:      def __init__(self, dag: nx.DiGraph):          self._sorted_nodes = list(nodes for nodes in nx.topological_generations(dag))          self._length, self._width = self.__compute_size()          self._grid_length, self._grid_width = self.__compute_grid_size()          self._nodes = self.__compute_nodes()          self._edges = self.__compute_edges(dag)        @property      def width(self) -> int:          return self._width        @property      def length(self) -> int:          return self._length        @property      def nodes(self) -> Dict[str, _Node]:          return self._nodes        @property      def edges(self) -> List[_Edge]:          return self._edges        def __compute_size(self) -> Tuple[int, int]:          return len(self._sorted_nodes), max([len(i) for i in self._sorted_nodes])        def __compute_grid_size(self) -> Tuple[int, int]:          if self._width == 1:              grd_wdt = 1          else:              grd_wdt = self.__lcm(*[len(i) + 1 if len(i) != self._width else len(i) - 1 for i in self._sorted_nodes]) + 1          return len(self._sorted_nodes), grd_wdt        def __compute_nodes(self) -> Dict[str, _Node]:          nodes = {}          x = 0          for same_lvl_nodes in self._sorted_nodes:              lcl_wdt = len(same_lvl_nodes)              is_max = lcl_wdt != self.width              if self.width != 1:                  y_incr = (self._grid_width - 1) / (lcl_wdt + 1) if is_max else (self._grid_width - 1) / (lcl_wdt - 1)              else:                  y_incr = 1              y = 0 if is_max else -y_incr              for node in same_lvl_nodes:                  y += y_incr                  nodes[node.id] = _Node(node, x, y)              x += 1          return nodes        def __compute_edges(self, dag) -> List[_Edge]:          edges = []          for edge in dag.edges():              edges.append(_Edge(self.nodes[edge[0].id], self.nodes[edge[1].id]))          return edges        @staticmethod      def __lcm(*integers) -> int:          # Function math.lcm is only implemented for Python 3.9+          # For compatibility with Python 3.8 it has been re implemented.          if 0 in integers:              return 0          return reduce(lambda x, y: (x * y) // math.gcd(x, y), integers) "}
{"text": "import sys  from typing import List    from taipy._cli._base_cli import _CLI  from taipy.logger._taipy_logger import _TaipyLogger    from ._migrate import (      _migrate_fs_entities,      _migrate_mongo_entities,      _migrate_sql_entities,      _remove_backup_file_entities,      _remove_backup_mongo_entities,      _remove_backup_sql_entities,      _restore_migrate_file_entities,      _restore_migrate_mongo_entities,      _restore_migrate_sql_entities,  )      class _MigrateCLI:      __logger = _TaipyLogger._get_logger()        @classmethod      def create_parser(cls):          migrate_parser = _CLI._add_subparser(              \"migrate\",              help=\"Migrate entities created from old taipy versions to be compatible with the current taipy version. \"              \" The entity migration should be performed only after updating taipy code to the current version.\",          )          migrate_parser.add_argument(              \"--repository-type\",              required=True,              nargs=\"+\",              help=\"The type of repository to migrate. If filesystem or sql, a path to the database folder/.sqlite file \"              \"should be informed. In case of mongo host, port, user and password must be informed, if left empty it \"              \"is assumed default values\",          )          migrate_parser.add_argument(              \"--skip-backup\",              action=\"store_true\",              help=\"Skip the backup of entities before migration.\",          )          migrate_parser.add_argument(              \"--restore\",              action=\"store_true\",              help=\"Restore the migration of entities from backup folder.\",          )          migrate_parser.add_argument(              \"--remove-backup\",              action=\"store_true\",              help=\"Remove the backup of entities. Only use this option if the migration was successful.\",          )        @classmethod      def parse_arguments(cls):          args = _CLI._parse()            if getattr(args, \"which\", None) != \"migrate\":              return            repository_type = args.repository_type[0]          repository_args = args.repository_type[1:] if len(args.repository_type) > 1 else [None]            if args.restore:              cls.__handle_restore_backup(repository_type, repository_args)          if args.remove_backup:              cls.__handle_remove_backup(repository_type, repository_args)            do_backup = False if args.skip_backup else True          cls.__migrate_entities(repository_type, repository_args, do_backup)          sys.exit(0)        @classmethod      def __handle_remove_backup(cls, repository_type: str, repository_args: List):          if repository_type == \"filesystem\":              path = repository_args[0] or \".data\"              if not _remove_backup_file_entities(path):                  sys.exit(1)          elif repository_type == \"sql\":              if not _remove_backup_sql_entities(repository_args[0]):                  sys.exit(1)          elif repository_type == \"mongo\":              if not _remove_backup_mongo_entities():                  sys.exit(1)          else:              cls.__logger.error(f\"Unknown repository type {repository_type}\")              sys.exit(1)            sys.exit(0)        @classmethod      def __handle_restore_backup(cls, repository_type: str, repository_args: List):          if repository_type == \"filesystem\":              path = repository_args[0] or \".data\"              if not _restore_migrate_file_entities(path):                  sys.exit(1)          elif repository_type == \"sql\":              if not _restore_migrate_sql_entities(repository_args[0]):                  sys.exit(1)          elif repository_type == \"mongo\":              mongo_args = repository_args[1:5] if repository_args[0] else []              if not _restore_migrate_mongo_entities(*mongo_args):                  sys.exit(1)          else:              cls.__logger.error(f\"Unknown repository type {repository_type}\")              sys.exit(1)          sys.exit(0)        @classmethod      def __migrate_entities(cls, repository_type: str, repository_args: List, do_backup: bool):          if repository_type == \"filesystem\":              path = repository_args[0] or \".data\"              if not _migrate_fs_entities(path, do_backup):                  sys.exit(1)            elif repository_type == \"sql\":              if not _migrate_sql_entities(repository_args[0], do_backup):                  sys.exit(1)            elif repository_type == \"mongo\":              mongo_args = repository_args[1:5] if repository_args[0] else []              _migrate_mongo_entities(*mongo_args, backup=do_backup)  # type: ignore            else:              cls.__logger.error(f\"Unknown repository type {repository_type}\")              sys.exit(1) "}
{"text": "import functools    from ..notification import EventOperation, Notifier, _make_event      class _Reloader:      \"\"\"The _Reloader singleton class\"\"\"        _instance = None        _no_reload_context = False        def __new__(class_, *args, **kwargs):          if not isinstance(class_._instance, class_):              class_._instance = object.__new__(class_, *args, **kwargs)          return class_._instance        def _reload(self, manager: str, obj):          if self._no_reload_context:              return obj            entity = _get_manager(manager)._get(obj, obj)          if obj._is_in_context and hasattr(entity, \"_properties\"):              if obj._properties._pending_changes:                  entity._properties._pending_changes = obj._properties._pending_changes              if obj._properties._pending_deletions:                  entity._properties._pending_deletions = obj._properties._pending_deletions              entity._properties._entity_owner = obj          return entity        def __enter__(self):          self._no_reload_context = True          return self        def __exit__(self, exc_type, exc_value, exc_traceback):          self._no_reload_context = False      def _self_reload(manager):      def __reload(fct):          @functools.wraps(fct)          def _do_reload(self, *args, **kwargs):              self = _Reloader()._reload(manager, self)              return fct(self, *args, **kwargs)            return _do_reload        return __reload      def _self_setter(manager):      def __set_entity(fct):          @functools.wraps(fct)          def _do_set_entity(self, *args, **kwargs):              fct(self, *args, **kwargs)              entity_manager = _get_manager(manager)              if len(args) == 1:                  value = args[0]              else:                  value = args              event = _make_event(                  self,                  EventOperation.UPDATE,                  attribute_name=fct.__name__,                  attribute_value=value,              )              if not self._is_in_context:                  entity = _Reloader()._reload(manager, self)                  fct(entity, *args, **kwargs)                  entity_manager._set(entity)                  Notifier.publish(event)              else:                  self._in_context_attributes_changed_collector.append(event)            return _do_set_entity        return __set_entity      @functools.lru_cache  def _get_manager(manager: str):      from ..cycle._cycle_manager_factory import _CycleManagerFactory      from ..data._data_manager_factory import _DataManagerFactory      from ..job._job_manager_factory import _JobManagerFactory      from ..scenario._scenario_manager_factory import _ScenarioManagerFactory      from ..sequence._sequence_manager_factory import _SequenceManagerFactory      from ..submission._submission_manager_factory import _SubmissionManagerFactory      from ..task._task_manager_factory import _TaskManagerFactory        return {          \"scenario\": _ScenarioManagerFactory._build_manager(),          \"sequence\": _SequenceManagerFactory._build_manager(),          \"data\": _DataManagerFactory._build_manager(),          \"cycle\": _CycleManagerFactory._build_manager(),          \"job\": _JobManagerFactory._build_manager(),          \"task\": _TaskManagerFactory._build_manager(),          \"submission\": _SubmissionManagerFactory._build_manager(),      }[manager] "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  import abc  from typing import Optional      class _Labeled:      __LABEL_SEPARATOR = \" > \"        @abc.abstractmethod      def get_label(self) -> str:          raise NotImplementedError        def _get_label(self) -> str:          \"\"\"Returns the entity label made of the simple label prefixed by the owner label.            Returns:              The label of the entity as a string.          \"\"\"          return self._get_explicit_label() or self._generate_label()        @abc.abstractmethod      def get_simple_label(self) -> str:          raise NotImplementedError        def _get_simple_label(self) -> str:          \"\"\"Returns the simple label.            Returns:              The simple label of the entity as a string.          \"\"\"          return self._get_explicit_label() or self._generate_label(True)        def _generate_label(self, simple=False) -> str:          ls = []          if not simple:              if owner_id := self._get_owner_id():                  if getattr(self, \"id\") != owner_id:                      from ... import core as tp                        owner = tp.get(owner_id)                      ls.append(owner.get_label())          ls.append(self._generate_entity_label())          return self.__LABEL_SEPARATOR.join(ls)        def _get_explicit_label(self) -> Optional[str]:          if hasattr(self, \"_properties\"):              return getattr(self, \"_properties\").get(\"label\")          return None        def _get_owner_id(self) -> Optional[str]:          if hasattr(self, \"owner_id\"):              return getattr(self, \"owner_id\")          return None        def _get_name(self) -> Optional[str]:          if hasattr(self, \"name\"):              return getattr(self, \"name\")          if hasattr(self, \"_properties\"):              return getattr(self, \"_properties\").get(\"name\")          return None        def _get_config_id(self) -> Optional[str]:          if hasattr(self, \"config_id\"):              return getattr(self, \"config_id\")          return None        def _generate_entity_label(self) -> str:          if name := self._get_name():              return name          if config_id := self._get_config_id():              return config_id          return getattr(self, \"id\") "}
{"text": "import os  import shutil  from functools import lru_cache  from typing import Dict    import bson  import pymongo    from taipy.logger._taipy_logger import _TaipyLogger    from ._utils import _migrate    __logger = _TaipyLogger._get_logger()      OLD_COLLECTIONS = [      \"cycle\",      \"scenario\",      \"pipeline\",      \"task\",      \"data_node\",      \"job\",      \"version\",  ]  NEW_COLLECTIONS = [      \"cycle\",      \"scenario\",      \"task\",      \"data_node\",      \"job\",      \"version\",  ]  DATABASE_NAME = \"taipy\"  MONGO_BACKUP_FOLDER = \".mongo_backup\"      @lru_cache  def _connect_mongodb(db_host: str, db_port: int, db_username: str, db_password: str) -> pymongo.MongoClient:      auth_str = \"\"      if db_username and db_password:          auth_str = f\"{db_username}:{db_password}@\"        connection_string = f\"mongodb://{auth_str}{db_host}:{db_port}\"        return pymongo.MongoClient(connection_string)      def __load_all_entities_from_mongo(      hostname: str,      port: int,      user: str,      password: str,  ):      client = _connect_mongodb(hostname, port, user, password)      entities = {}      for collection in OLD_COLLECTIONS:          db = client[DATABASE_NAME]          cursor = db[collection].find({})          for document in cursor:              entities[document[\"id\"]] = {\"data\": document}        return entities      def __write_entities_to_mongo(      _entities: Dict,      hostname: str,      port: int,      user: str,      password: str,  ):      client = _connect_mongodb(hostname, port, user, password)      for collection in NEW_COLLECTIONS:          db = client[DATABASE_NAME]          db[collection].insert_many(              [entity[\"data\"] for entity in _entities.values() if collection in entity[\"data\"][\"id\"]]          )      def _backup_mongo_entities(      hostname: str = \"localhost\",      port: int = 27017,      user: str = \"\",      password: str = \"\",  ) -> bool:      client = _connect_mongodb(hostname, port, user, password)      db = client[DATABASE_NAME]        if not os.path.exists(MONGO_BACKUP_FOLDER):          os.makedirs(MONGO_BACKUP_FOLDER, exist_ok=True)        for collection in OLD_COLLECTIONS:          with open(os.path.join(MONGO_BACKUP_FOLDER, f\"{collection}.bson\"), \"wb+\") as f:              for doc in db[collection].find():                  f.write(bson.BSON.encode(doc))      __logger.info(f\"Backed up entities to folder '{MONGO_BACKUP_FOLDER}' before migration.\")      return True      def _restore_migrate_mongo_entities(      hostname: str = \"localhost\",      port: int = 27017,      user: str = \"\",      password: str = \"\",  ) -> bool:      client = _connect_mongodb(hostname, port, user, password)      db = client[DATABASE_NAME]        if not os.path.isdir(MONGO_BACKUP_FOLDER):          __logger.info(f\"The backup folder '{MONGO_BACKUP_FOLDER}' does not exist.\")          return False        for collection in os.listdir(MONGO_BACKUP_FOLDER):          if collection.endswith(\".bson\"):              with open(os.path.join(MONGO_BACKUP_FOLDER, collection), \"rb+\") as f:                  if bson_data := bson.decode_all(f.read()):  # type: ignore                      db[collection.split(\".\")[0]].insert_many(bson_data)        shutil.rmtree(MONGO_BACKUP_FOLDER)      __logger.info(f\"Restored entities from the backup folder '{MONGO_BACKUP_FOLDER}'.\")      return True      def _remove_backup_mongo_entities() -> bool:      if not os.path.isdir(MONGO_BACKUP_FOLDER):          __logger.info(f\"The backup folder '{MONGO_BACKUP_FOLDER}' does not exist.\")          return False        shutil.rmtree(MONGO_BACKUP_FOLDER)      __logger.info(f\"Removed backup entities from the backup folder '{MONGO_BACKUP_FOLDER}'.\")      return True      def _migrate_mongo_entities(      hostname: str = \"localhost\",      port: int = 27017,      user: str = \"\",      password: str = \"\",      backup: bool = True,  ) -> bool:      \"\"\"Migrate entities from mongodb to the current version.        Args:          hostname (str, optional): The hostname of the mongodb. Defaults to \"localhost\".          port (int, optional): The port of the mongodb. Defaults to 27017.          user (str, optional): The username of the mongodb. Defaults to \"\".          password (str, optional): The password of the mongodb. Defaults to \"\".          backup (bool, optional): Whether to backup the entities before migrating. Defaults to True.        Returns:          bool: True if the migration was successful, False otherwise.      \"\"\"      if backup:          _backup_mongo_entities(hostname=hostname, port=port, user=user, password=password)        __logger.info(f\"Starting entity migration from MongoDB {hostname}:{port}\")        entities = __load_all_entities_from_mongo(hostname, port, user, password)      entities, _ = _migrate(entities)      __write_entities_to_mongo(entities, hostname, port, user, password)        __logger.info(\"Migration finished\")      return True "}
{"text": "from ._migrate_fs import _migrate_fs_entities, _remove_backup_file_entities, _restore_migrate_file_entities  from ._migrate_mongo import _migrate_mongo_entities, _remove_backup_mongo_entities, _restore_migrate_mongo_entities  from ._migrate_sql import _migrate_sql_entities, _remove_backup_sql_entities, _restore_migrate_sql_entities "}
{"text": "import json  import os  import shutil  from typing import Dict    from taipy.logger._taipy_logger import _TaipyLogger    from ._utils import _migrate    __logger = _TaipyLogger._get_logger()      def _load_all_entities_from_fs(root: str) -> Dict:      # run through all files in the data folder and load them      entities = {}      for root, dirs, files in os.walk(root):          for file in files:              if file.endswith(\".json\"):                  with open(os.path.join(root, file)) as f:                      _id = file.split(\".\")[0]                      if \"version\" in root:                          _id = f\"VERSION_{_id}\"                      entities[_id] = {                          \"data\": json.load(f),                          \"path\": os.path.join(root, file),                      }      return entities      def __write_entities_to_fs(_entities: Dict, root: str):      if not os.path.exists(root):          os.makedirs(root, exist_ok=True)        for _id, entity in _entities.items():          # Do not write pipeline entities          if \"PIPELINE\" in _id:              continue          with open(entity[\"path\"], \"w\") as f:              json.dump(entity[\"data\"], f, indent=0)        # Remove pipelines folder      pipelines_path = os.path.join(root, \"pipelines\")      if os.path.exists(pipelines_path):          shutil.rmtree(pipelines_path)      def _restore_migrate_file_entities(path: str) -> bool:      backup_path = f\"{path}_backup\"        if not os.path.exists(backup_path):          __logger.error(f\"The backup folder '{backup_path}' does not exist.\")          return False        if os.path.exists(path):          shutil.rmtree(path)      else:          __logger.warning(f\"The original entities folder '{path}' does not exist.\")        os.rename(backup_path, path)      __logger.info(f\"Restored entities from the backup folder '{backup_path}' to '{path}'.\")      return True      def _remove_backup_file_entities(path: str) -> bool:      backup_path = f\"{path}_backup\"      if not os.path.exists(backup_path):          __logger.error(f\"The backup folder '{backup_path}' does not exist.\")          return False        shutil.rmtree(backup_path)      __logger.info(f\"Removed backup entities from the backup folder '{backup_path}'.\")      return True      def _migrate_fs_entities(path: str, backup: bool = True) -> bool:      \"\"\"Migrate entities from filesystem to the current version.        Args:          path (str): The path to the folder containing the entities.          backup (bool, optional): Whether to backup the entities before migrating. Defaults to True.        Returns:          bool: True if the migration was successful, False otherwise.      \"\"\"      if not os.path.isdir(path):          __logger.error(f\"Folder '{path}' does not exist.\")          return False        if backup:          backup_path = f\"{path}_backup\"          try:              shutil.copytree(path, backup_path)          except FileExistsError:              __logger.warning(f\"The backup folder '{backup_path}' already exists. Migration canceled.\")              return False          else:              __logger.info(f\"Backed up entities from '{path}' to '{backup_path}' folder before migration.\")        __logger.info(f\"Starting entity migration from '{path}' folder.\")        entities = _load_all_entities_from_fs(path)      entities, _ = _migrate(entities)      __write_entities_to_fs(entities, path)        __logger.info(\"Migration finished\")      return True "}
{"text": "from functools import lru_cache    import pymongo      @lru_cache  def _connect_mongodb(      db_host: str, db_port: int, db_username: str, db_password: str, db_extra_args: frozenset, db_driver: str  ) -> pymongo.MongoClient:      \"\"\"Create a connection to a Mongo database.      The `\"mongodb_extra_args\"` passed by the user is originally a dictionary, but since `@lru_cache` wrapper only      accepts hashable parameters, the `\"mongodb_extra_args\"` should be converted into a frozenset beforehand.        Parameters:          db_host (str): the database host.          db_port (int): the database port.          db_username (str): the database username.          db_password (str): the database password.          db_extra_args (frozenset): A frozenset converted from a dictionary of additional arguments to be passed into              database connection string.      Returns:          pymongo.MongoClient      \"\"\"      auth_str = \"\"      if db_username and db_password:          auth_str = f\"{db_username}:{db_password}@\"        extra_args_str = \"&\".join(f\"{k}={str(v)}\" for k, v in db_extra_args)      if extra_args_str:          extra_args_str = \"/?\" + extra_args_str        driver = \"mongodb\"      if db_driver:          driver = f\"{driver}+{db_driver}\"        connection_string = f\"{driver}://{auth_str}{db_host}\"      connection_string = connection_string if db_driver else f\"{connection_string}:{db_port}\"      connection_string += extra_args_str        return pymongo.MongoClient(connection_string) "}
{"text": "from taipy.config.common._validate_id import _validate_id      class MongoDefaultDocument:      \"\"\"The default class for \\\"custom_document\\\" property to configure a `MongoCollectionDataNode^`.        Attributes:          **kwargs: Attributes of the MongoDefaultDocument object.        Example:          - `document = MongoDefaultDocument(name=\"example\", age=30})`          will return a MongoDefaultDocument object so that `document.name` returns `\"example\"`,          and `document.age` returns `30`.          - `document = MongoDefaultDocument(date=\"12/24/2018\", temperature=20})`          will return a MongoDefaultDocument object so that `document.date` returns `\"12/24/2018\"`,          and `document.temperature` returns `20`.      \"\"\"        def __init__(self, **kwargs):          for attribute_name, value in kwargs.items():              setattr(self, _validate_id(attribute_name), value) "}
{"text": "from .mongo_default_document import MongoDefaultDocument "}
{"text": "from collections import UserList      class _ListAttributes(UserList):      def __init__(self, parent, *args, **kwargs):          super().__init__(*args, **kwargs)          self._parent = parent        def __add_iterable(self, iterable):          for i in iterable:              super(_ListAttributes, self).append(i)        def __set_self(self):          from ... import core as tp            if hasattr(self, \"_parent\"):              tp.set(self._parent)        def __add__(self, value):          if hasattr(value, \"__iter__\"):              self.__add_iterable(value)          else:              self.append(value)          return self        def extend(self, value) -> None:          super(_ListAttributes, self).extend(value)          self.__set_self()        def append(self, value) -> None:          super(_ListAttributes, self).append(value)          self.__set_self()        def remove(self, value):          super(_ListAttributes, self).remove(value)          self.__set_self()        def clear(self) -> None:          super(_ListAttributes, self).clear()          self.__set_self() "}
{"text": "import functools  import warnings  from typing import Optional    warnings.simplefilter(\"once\", ResourceWarning)      def _warn_deprecated(deprecated: str, suggest: Optional[str] = None, stacklevel: int = 3) -> None:      category = DeprecationWarning      message = f\"{deprecated} is deprecated.\"      if suggest:          message += f\" Use {suggest} instead.\"      warnings.warn(message=message, category=category, stacklevel=stacklevel)      def _warn_no_core_service(stacklevel: int = 3):      def inner(f):          @functools.wraps(f)          def _check_if_core_service_is_running(*args, **kwargs):              from .._orchestrator._orchestrator_factory import _OrchestratorFactory                if not _OrchestratorFactory._dispatcher:                  message = \"The Core service is NOT running\"                  warnings.warn(message=message, category=ResourceWarning, stacklevel=stacklevel)                return f(*args, **kwargs)            return _check_if_core_service_is_running        return inner "}
{"text": "import functools  from enum import Enum      class _ReprEnum(Enum):      @classmethod      @functools.lru_cache      def _from_repr(cls, repr_: str):          return next(filter(lambda e: repr(e) == repr_, cls))  # type: ignore "}
{"text": "from typing import Iterable    from taipy.logger._taipy_logger import _TaipyLogger    from ..data import DataNode      def _warn_if_inputs_not_ready(inputs: Iterable[DataNode]):      from ..data import CSVDataNode, ExcelDataNode, JSONDataNode, ParquetDataNode, PickleDataNode      from ..data._data_manager_factory import _DataManagerFactory        logger = _TaipyLogger._get_logger()      data_manager = _DataManagerFactory._build_manager()      for dn in inputs:          dn = data_manager._get(dn.id)          if dn.is_ready_for_reading is False and not dn._last_edit_date:              if dn.storage_type() in [                  CSVDataNode.storage_type(),                  ExcelDataNode.storage_type(),                  JSONDataNode.storage_type(),                  PickleDataNode.storage_type(),                  ParquetDataNode.storage_type(),              ]:                  logger.warning(                      f\"{dn.id} cannot be read because it has never been written. \"                      f\"Hint: The data node may refer to a wrong path : {dn.path} \"                  )              else:                  logger.warning(f\"{dn.id} cannot be read because it has never been written.\") "}
{"text": "from typing import TypeVar, Union    from .._repository._abstract_converter import _AbstractConverter  from .._repository._base_taipy_model import _BaseModel    ModelType = TypeVar(\"ModelType\", bound=_BaseModel)  Entity = TypeVar(\"Entity\")  Converter = TypeVar(\"Converter\", bound=_AbstractConverter)  Json = Union[dict, list, str, int, float, bool] "}
{"text": "import functools  import time  from collections import namedtuple  from importlib import import_module  from operator import attrgetter  from typing import Callable, Optional, Tuple    from taipy.config import Config      @functools.lru_cache  def _load_fct(module_name: str, fct_name: str) -> Callable:      module = import_module(module_name)      return attrgetter(fct_name)(module)      def _retry_read_entity(exceptions: Tuple, sleep_time: float = 0.2):      \"\"\"      Retries the wrapped function/method if the exceptions listed      in ``exceptions`` are thrown.      The number of retries is defined by Config.core.read_entity_retry.        Parameters:          exceptions (tuple): Tuple of exceptions that trigger a retry attempt.          sleep_time (float): Time to sleep between retries.      \"\"\"        def decorator(func):          def newfn(*args, **kwargs):              for _ in range(Config.core.read_entity_retry):                  try:                      return func(*args, **kwargs)                  except exceptions:                      time.sleep(sleep_time)              return func(*args, **kwargs)            return newfn        return decorator      @functools.lru_cache  def _get_fct_name(f) -> Optional[str]:      # Mock function does not have __qualname__ attribute -> return __name__      # Partial or anonymous function does not have __name__ or __qualname__ attribute -> return None      name = getattr(f, \"__qualname__\", getattr(f, \"__name__\", None))      return name      def _fct_to_dict(obj):      params = []      callback = obj        if isinstance(obj, _Subscriber):          callback = obj.callback          params = obj.params        fct_name = _get_fct_name(callback)      if not fct_name:          return None      return {          \"fct_name\": fct_name,          \"fct_params\": params,          \"fct_module\": callback.__module__,      }      def _fcts_to_dict(objs):      return [d for obj in objs if (d := _fct_to_dict(obj)) is not None]      _Subscriber = namedtuple(\"_Subscriber\", \"callback params\") "}
{"text": "from typing import Type    from .._manager._manager_factory import _ManagerFactory  from ..common._utils import _load_fct  from ._scenario_fs_repository import _ScenarioFSRepository  from ._scenario_manager import _ScenarioManager  from ._scenario_sql_repository import _ScenarioSQLRepository      class _ScenarioManagerFactory(_ManagerFactory):        __REPOSITORY_MAP = {\"default\": _ScenarioFSRepository, \"sql\": _ScenarioSQLRepository}        @classmethod      def _build_manager(cls) -> Type[_ScenarioManager]:  # type: ignore          if cls._using_enterprise():              scenario_manager = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".scenario._scenario_manager\", \"_ScenarioManager\"              )  # type: ignore              build_repository = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".scenario._scenario_manager_factory\", \"_ScenarioManagerFactory\"              )._build_repository  # type: ignore          else:              scenario_manager = _ScenarioManager              build_repository = cls._build_repository          scenario_manager._repository = build_repository()  # type: ignore          return scenario_manager  # type: ignore        @classmethod      def _build_repository(cls):          return cls._get_repository_with_repo_map(cls.__REPOSITORY_MAP)() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from dataclasses import dataclass  from typing import Any, Dict, List, Optional    from sqlalchemy import JSON, Boolean, Column, String, Table    from .._repository._base_taipy_model import _BaseModel  from .._repository.db._sql_base_model import mapper_registry  from ..cycle.cycle_id import CycleId  from ..data.data_node_id import DataNodeId  from ..task.task_id import TaskId  from .scenario_id import ScenarioId      @mapper_registry.mapped  @dataclass  class _ScenarioModel(_BaseModel):      __table__ = Table(          \"scenario\",          mapper_registry.metadata,          Column(\"id\", String, primary_key=True),          Column(\"config_id\", String),          Column(\"tasks\", JSON),          Column(\"additional_data_nodes\", JSON),          Column(\"properties\", JSON),          Column(\"creation_date\", String),          Column(\"primary_scenario\", Boolean),          Column(\"subscribers\", JSON),          Column(\"tags\", JSON),          Column(\"version\", String),          Column(\"sequences\", JSON),          Column(\"cycle\", String),      )      id: ScenarioId      config_id: str      tasks: List[TaskId]      additional_data_nodes: List[DataNodeId]      properties: Dict[str, Any]      creation_date: str      primary_scenario: bool      subscribers: List[Dict]      tags: List[str]      version: str      sequences: Optional[Dict[str, Dict]] = None      cycle: Optional[CycleId] = None        @staticmethod      def from_dict(data: Dict[str, Any]):          return _ScenarioModel(              id=data[\"id\"],              config_id=data[\"config_id\"],              tasks=_BaseModel._deserialize_attribute(data[\"tasks\"]),              additional_data_nodes=_BaseModel._deserialize_attribute(data[\"additional_data_nodes\"]),              properties=_BaseModel._deserialize_attribute(data[\"properties\"]),              creation_date=data[\"creation_date\"],              primary_scenario=data[\"primary_scenario\"],              subscribers=_BaseModel._deserialize_attribute(data[\"subscribers\"]),              tags=_BaseModel._deserialize_attribute(data[\"tags\"]),              version=data[\"version\"],              sequences=_BaseModel._deserialize_attribute(data[\"sequences\"]),              cycle=CycleId(data[\"cycle\"]) if \"cycle\" in data else None,          )        def to_list(self):          return [              self.id,              self.config_id,              _BaseModel._serialize_attribute(self.tasks),              _BaseModel._serialize_attribute(self.additional_data_nodes),              _BaseModel._serialize_attribute(self.properties),              self.creation_date,              self.primary_scenario,              _BaseModel._serialize_attribute(self.subscribers),              _BaseModel._serialize_attribute(self.tags),              self.version,              _BaseModel._serialize_attribute(self.sequences),              self.cycle,          ] "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._filesystem_repository import _FileSystemRepository  from ._scenario_converter import _ScenarioConverter  from ._scenario_model import _ScenarioModel      class _ScenarioFSRepository(_FileSystemRepository):      def __init__(self):          super().__init__(model_type=_ScenarioModel, converter=_ScenarioConverter, dir_name=\"scenarios\") "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._sql_repository import _SQLRepository  from ._scenario_converter import _ScenarioConverter  from ._scenario_model import _ScenarioModel      class _ScenarioSQLRepository(_SQLRepository):      def __init__(self):          super().__init__(model_type=_ScenarioModel, converter=_ScenarioConverter) "}
{"text": "from datetime import datetime  from typing import Dict, List, Optional, Set, Union    from .._repository._abstract_converter import _AbstractConverter  from .._version._utils import _migrate_entity  from ..common import _utils  from ..cycle._cycle_manager_factory import _CycleManagerFactory  from ..cycle.cycle import Cycle, CycleId  from ..data.data_node import DataNode, DataNodeId  from ..scenario._scenario_model import _ScenarioModel  from ..scenario.scenario import Scenario  from ..task.task import Task, TaskId      class _ScenarioConverter(_AbstractConverter):      @classmethod      def _entity_to_model(cls, scenario: Scenario) -> _ScenarioModel:          sequences: Dict[str, Dict[str, Union[List[TaskId], Dict, List]]] = {}          for p_name, sequence_data in scenario._sequences.items():              sequences[p_name] = {                  Scenario._SEQUENCE_TASKS_KEY: [                      t.id if isinstance(t, Task) else t for t in sequence_data.get(\"tasks\", [])                  ],                  Scenario._SEQUENCE_PROPERTIES_KEY: sequence_data.get(\"properties\", {}),                  Scenario._SEQUENCE_SUBSCRIBERS_KEY: _utils._fcts_to_dict(sequence_data.get(\"subscribers\", [])),              }            return _ScenarioModel(              id=scenario.id,              config_id=scenario.config_id,              tasks=[task.id if isinstance(task, Task) else TaskId(str(task)) for task in list(scenario._tasks)],              additional_data_nodes=[                  dn.id if isinstance(dn, DataNode) else DataNodeId(str(dn))                  for dn in list(scenario._additional_data_nodes)              ],              properties=scenario._properties.data,              creation_date=scenario._creation_date.isoformat(),              primary_scenario=scenario._primary_scenario,              subscribers=_utils._fcts_to_dict(scenario._subscribers),              tags=list(scenario._tags),              version=scenario._version,              cycle=scenario._cycle.id if scenario._cycle else None,              sequences=sequences if sequences else None,          )        @classmethod      def _model_to_entity(cls, model: _ScenarioModel) -> Scenario:          tasks: Union[Set[TaskId], Set[Task], Set] = set()          if model.tasks:              tasks = set(model.tasks)          if model.sequences:              for sequence_name, sequence_data in model.sequences.items():                  if subscribers := sequence_data.get(Scenario._SEQUENCE_SUBSCRIBERS_KEY):                      model.sequences[sequence_name][Scenario._SEQUENCE_SUBSCRIBERS_KEY] = [                          _utils._Subscriber(_utils._load_fct(it[\"fct_module\"], it[\"fct_name\"]), it[\"fct_params\"])                          for it in subscribers                      ]            scenario = Scenario(              scenario_id=model.id,              config_id=model.config_id,              tasks=tasks,              additional_data_nodes=set(model.additional_data_nodes),              properties=model.properties,              creation_date=datetime.fromisoformat(model.creation_date),              is_primary=model.primary_scenario,              tags=set(model.tags),              cycle=cls.__to_cycle(model.cycle),              subscribers=[                  _utils._Subscriber(_utils._load_fct(it[\"fct_module\"], it[\"fct_name\"]), it[\"fct_params\"])                  for it in model.subscribers              ],              version=model.version,              sequences=model.sequences,          )          return _migrate_entity(scenario)        @staticmethod      def __to_cycle(cycle_id: Optional[CycleId] = None) -> Optional[Cycle]:          return _CycleManagerFactory._build_manager()._get(cycle_id) if cycle_id else None "}
{"text": "from typing import NewType    ScenarioId = NewType(\"ScenarioId\", str)  ScenarioId.__doc__ = \"\"\"Type that holds a `Scenario^` identifier.\"\"\" "}
{"text": "from abc import abstractmethod  from typing import Callable, Iterable, List, Optional, Union    from ..job.job import Job  from ..task.task import Task      class _AbstractOrchestrator:      \"\"\"Creates, enqueues, and orchestrates jobs as instances of `Job^` class.\"\"\"        @classmethod      @abstractmethod      def initialize(cls):          raise NotImplementedError        @classmethod      @abstractmethod      def submit(          cls,          sequence,          callbacks: Optional[Iterable[Callable]],          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,      ) -> List[Job]:          raise NotImplementedError        @classmethod      @abstractmethod      def submit_task(          cls,          task: Task,          callbacks: Optional[Iterable[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,      ) -> Job:          raise NotImplementedError        @classmethod      @abstractmethod      def cancel_job(cls, job):          raise NotImplementedError "}
{"text": "from importlib import util  from typing import Optional, Type    from taipy.config.config import Config    from ..common._utils import _load_fct  from ..exceptions.exceptions import ModeNotAvailable, OrchestratorNotBuilt  from ._abstract_orchestrator import _AbstractOrchestrator  from ._dispatcher import _DevelopmentJobDispatcher, _JobDispatcher, _StandaloneJobDispatcher  from ._orchestrator import _Orchestrator      class _OrchestratorFactory:      _TAIPY_ENTERPRISE_MODULE = \"taipy.enterprise\"      _TAIPY_ENTERPRISE_CORE_ORCHESTRATOR_MODULE = _TAIPY_ENTERPRISE_MODULE + \".core._orchestrator._orchestrator\"      _TAIPY_ENTERPRISE_CORE_DISPATCHER_MODULE = _TAIPY_ENTERPRISE_MODULE + \".core._orchestrator._dispatcher\"      __TAIPY_ENTERPRISE_BUILD_DISPATCHER_METHOD = \"_build_dispatcher\"        _orchestrator: Optional[_Orchestrator] = None      _dispatcher: Optional[_JobDispatcher] = None        @classmethod      def _build_orchestrator(cls) -> Type[_AbstractOrchestrator]:          if util.find_spec(cls._TAIPY_ENTERPRISE_MODULE) is not None:              cls._orchestrator = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_ORCHESTRATOR_MODULE,                  \"Orchestrator\",              )  # type: ignore          else:              cls._orchestrator = _Orchestrator  # type: ignore            cls._orchestrator.initialize()  # type: ignore            return cls._orchestrator  # type: ignore        @classmethod      def _build_dispatcher(cls, force_restart=False) -> Optional[_JobDispatcher]:          if not cls._orchestrator:              raise OrchestratorNotBuilt          if Config.job_config.is_standalone:              cls.__build_standalone_job_dispatcher(force_restart=force_restart)          elif Config.job_config.is_development:              cls.__build_development_job_dispatcher()          elif util.find_spec(cls._TAIPY_ENTERPRISE_MODULE):              cls.__build_enterprise_job_dispatcher(force_restart=force_restart)          else:              raise ModeNotAvailable(f\"Job mode {Config.job_config.mode} is not available.\")          return cls._dispatcher        @classmethod      def _remove_dispatcher(cls) -> Optional[_JobDispatcher]:          if cls._dispatcher is not None and not isinstance(cls._dispatcher, _DevelopmentJobDispatcher):              cls._dispatcher.stop()          cls._dispatcher = None          return cls._dispatcher        @classmethod      def __build_standalone_job_dispatcher(cls, force_restart=False):          if isinstance(cls._dispatcher, _StandaloneJobDispatcher):              if force_restart:                  cls._dispatcher.stop()              else:                  return            if util.find_spec(cls._TAIPY_ENTERPRISE_MODULE) is not None:              cls._dispatcher = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_DISPATCHER_MODULE, cls.__TAIPY_ENTERPRISE_BUILD_DISPATCHER_METHOD              )(cls._orchestrator)          else:              cls._dispatcher = _StandaloneJobDispatcher(cls._orchestrator)  # type: ignore          cls._dispatcher.start()  # type: ignore        @classmethod      def __build_development_job_dispatcher(cls):          if isinstance(cls._dispatcher, _StandaloneJobDispatcher):              cls._dispatcher.stop()          cls._dispatcher = _DevelopmentJobDispatcher(cls._orchestrator)  # type: ignore        @classmethod      def __build_enterprise_job_dispatcher(cls, force_restart=False):          cls._dispatcher = _load_fct(              cls._TAIPY_ENTERPRISE_CORE_DISPATCHER_MODULE, cls.__TAIPY_ENTERPRISE_BUILD_DISPATCHER_METHOD          )(cls._orchestrator, force_restart)          if cls._dispatcher:              cls._dispatcher.start()          else:              raise ModeNotAvailable(f\"Job mode {Config.job_config.mode} is not available.\") "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from ._development_job_dispatcher import _DevelopmentJobDispatcher  from ._job_dispatcher import _JobDispatcher  from ._standalone_job_dispatcher import _StandaloneJobDispatcher "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from typing import Optional    from ...job.job import Job  from .._abstract_orchestrator import _AbstractOrchestrator  from ._job_dispatcher import _JobDispatcher      class _DevelopmentJobDispatcher(_JobDispatcher):      \"\"\"Manages job dispatching (instances of `Job^` class) in a synchronous way.\"\"\"        def __init__(self, orchestrator: Optional[_AbstractOrchestrator]):          super().__init__(orchestrator)        def start(self):          raise NotImplementedError        def is_running(self) -> bool:          return True        def stop(self):          raise NotImplementedError        def run(self):          raise NotImplementedError        def _dispatch(self, job: Job):          \"\"\"Dispatches the given `Job^` on an available worker for execution.            Parameters:              job (Job^): The job to submit on an executor with an available worker.          \"\"\"          rs = self._wrapped_function(job.id, job.task)          self._update_job_status(job, rs) "}
{"text": "from concurrent.futures import ProcessPoolExecutor  from functools import partial  from typing import Optional    from taipy.config._serializer._toml_serializer import _TomlSerializer  from taipy.config.config import Config    from ...job.job import Job  from .._abstract_orchestrator import _AbstractOrchestrator  from ._job_dispatcher import _JobDispatcher      class _StandaloneJobDispatcher(_JobDispatcher):      \"\"\"Manages job dispatching (instances of `Job^` class) in an asynchronous way using a ProcessPoolExecutor.\"\"\"        def __init__(self, orchestrator: Optional[_AbstractOrchestrator]):          super().__init__(orchestrator)          self._executor = ProcessPoolExecutor(Config.job_config.max_nb_of_workers or 1)  # type: ignore          self._nb_available_workers = self._executor._max_workers  # type: ignore        def _dispatch(self, job: Job):          \"\"\"Dispatches the given `Job^` on an available worker for execution.            Parameters:              job (Job^): The job to submit on an executor with an available worker.          \"\"\"          self._nb_available_workers -= 1            config_as_string = _TomlSerializer()._serialize(Config._applied_config)          future = self._executor.submit(self._wrapped_function_with_config_load, config_as_string, job.id, job.task)            self._set_dispatched_processes(job.id, future)  # type: ignore          future.add_done_callback(self._release_worker)          future.add_done_callback(partial(self._update_job_status_from_future, job))        def _release_worker(self, _):          self._nb_available_workers += 1        def _update_job_status_from_future(self, job: Job, ft):          self._pop_dispatched_process(job.id)  # type: ignore          self._update_job_status(job, ft.result()) "}
{"text": "import threading  from abc import abstractmethod  from typing import Dict, Optional    from taipy.config.config import Config  from taipy.logger._taipy_logger import _TaipyLogger    from ...data._data_manager_factory import _DataManagerFactory  from ...job._job_manager_factory import _JobManagerFactory  from ...job.job import Job  from ...task.task import Task  from .._abstract_orchestrator import _AbstractOrchestrator  from ._task_function_wrapper import _TaskFunctionWrapper      class _JobDispatcher(threading.Thread, _TaskFunctionWrapper):      \"\"\"Manages job dispatching (instances of `Job^` class) on executors.\"\"\"        _STOP_FLAG = False      _dispatched_processes: Dict = {}      __logger = _TaipyLogger._get_logger()      _nb_available_workers: int = 1        def __init__(self, orchestrator: Optional[_AbstractOrchestrator]):          threading.Thread.__init__(self, name=\"Thread-Taipy-JobDispatcher\")          self.daemon = True          self.orchestrator = orchestrator          self.lock = self.orchestrator.lock  # type: ignore          Config.block_update()        def start(self):          \"\"\"Start the dispatcher\"\"\"          threading.Thread.start(self)        def is_running(self) -> bool:          \"\"\"Return True if the dispatcher is running\"\"\"          return self.is_alive()        def stop(self):          \"\"\"Stop the dispatcher\"\"\"          self._STOP_FLAG = True        def run(self):          _TaipyLogger._get_logger().info(\"Start job dispatcher...\")          while not self._STOP_FLAG:              try:                  if self._can_execute():                      with self.lock:                          job = self.orchestrator.jobs_to_run.get(block=True, timeout=0.1)                      self._execute_job(job)              except Exception:  # In case the last job of the queue has been removed.                  pass        def _can_execute(self) -> bool:          \"\"\"Returns True if the dispatcher have resources to execute a new job.\"\"\"          return self._nb_available_workers > 0        def _execute_job(self, job: Job):          if job.force or self._needs_to_run(job.task):              if job.force:                  self.__logger.info(f\"job {job.id} is forced to be executed.\")              job.running()              self._dispatch(job)          else:              job._unlock_edit_on_outputs()              job.skipped()              self.__logger.info(f\"job {job.id} is skipped.\")        def _execute_jobs_synchronously(self):          while not self.orchestrator.jobs_to_run.empty():              with self.lock:                  try:                      job = self.orchestrator.jobs_to_run.get()                  except Exception:  # In case the last job of the queue has been removed.                      self.__logger.warning(f\"{job.id} is no longer in the list of jobs to run.\")              self._execute_job(job)        @staticmethod      def _needs_to_run(task: Task) -> bool:          \"\"\"          Returns True if the task has no output or if at least one input was modified since the latest run.            Parameters:               task (Task^): The task to run.          Returns:               True if the task needs to run. False otherwise.          \"\"\"          if not task.skippable:              return True          data_manager = _DataManagerFactory._build_manager()          if len(task.output) == 0:              return True          are_outputs_in_cache = all(data_manager._get(dn.id).is_valid for dn in task.output.values())          if not are_outputs_in_cache:              return True          if len(task.input) == 0:              return False          input_last_edit = max(data_manager._get(dn.id).last_edit_date for dn in task.input.values())          output_last_edit = min(data_manager._get(dn.id).last_edit_date for dn in task.output.values())          return input_last_edit > output_last_edit        @abstractmethod      def _dispatch(self, job: Job):          \"\"\"          Dispatches the given `Job^` on an available worker for execution.            Parameters:              job (Job^): The job to submit on an executor with an available worker.          \"\"\"          raise NotImplementedError        @staticmethod      def _update_job_status(job: Job, exceptions):          job.update_status(exceptions)          _JobManagerFactory._build_manager()._set(job)        @classmethod      def _set_dispatched_processes(cls, job_id, process):          cls._dispatched_processes[job_id] = process        @classmethod      def _pop_dispatched_process(cls, job_id, default=None):          return cls._dispatched_processes.pop(job_id, default)  # type: ignore "}
{"text": "from typing import Any, List    from taipy.config._serializer._toml_serializer import _TomlSerializer  from taipy.config.config import Config    from ...data._data_manager_factory import _DataManagerFactory  from ...data.data_node import DataNode  from ...exceptions import DataNodeWritingError  from ...job.job_id import JobId  from ...task.task import Task      class _TaskFunctionWrapper:      @classmethod      def _wrapped_function_with_config_load(cls, config_as_string, job_id: JobId, task: Task):          Config._applied_config._update(_TomlSerializer()._deserialize(config_as_string))          Config.block_update()          return cls._wrapped_function(job_id, task)        @classmethod      def _wrapped_function(cls, job_id: JobId, task: Task):          try:              inputs: List[DataNode] = list(task.input.values())              outputs: List[DataNode] = list(task.output.values())                fct = task.function                results = fct(*cls.__read_inputs(inputs))              return cls.__write_data(outputs, results, job_id)          except Exception as e:              return [e]        @classmethod      def __read_inputs(cls, inputs: List[DataNode]) -> List[Any]:          data_manager = _DataManagerFactory._build_manager()          return [data_manager._get(dn.id).read_or_raise() for dn in inputs]        @classmethod      def __write_data(cls, outputs: List[DataNode], results, job_id: JobId):          data_manager = _DataManagerFactory._build_manager()          try:              if outputs:                  _results = cls.__extract_results(outputs, results)                  exceptions = []                  for res, dn in zip(_results, outputs):                      try:                          data_node = data_manager._get(dn.id)                          data_node.write(res, job_id=job_id)                          data_manager._set(data_node)                      except Exception as e:                          exceptions.append(DataNodeWritingError(f\"Error writing in datanode id {dn.id}: {e}\"))                  return exceptions          except Exception as e:              return [e]        @classmethod      def __extract_results(cls, outputs: List[DataNode], results: Any) -> List[Any]:          _results: List[Any] = [results] if len(outputs) == 1 else results          if len(_results) != len(outputs):              raise DataNodeWritingError(\"Error: wrong number of result or task output\")          return _results "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from typing import Type    from .._manager._manager_factory import _ManagerFactory  from ..common._utils import _load_fct  from ._task_fs_repository import _TaskFSRepository  from ._task_manager import _TaskManager  from ._task_sql_repository import _TaskSQLRepository      class _TaskManagerFactory(_ManagerFactory):        __REPOSITORY_MAP = {\"default\": _TaskFSRepository, \"sql\": _TaskSQLRepository}        @classmethod      def _build_manager(cls) -> Type[_TaskManager]:  # type: ignore          if cls._using_enterprise():              task_manager = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".task._task_manager\", \"_TaskManager\"              )  # type: ignore              build_repository = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".task._task_manager_factory\", \"_TaskManagerFactory\"              )._build_repository  # type: ignore          else:              task_manager = _TaskManager              build_repository = cls._build_repository          task_manager._repository = build_repository()  # type: ignore          return task_manager  # type: ignore        @classmethod      def _build_repository(cls):          return cls._get_repository_with_repo_map(cls.__REPOSITORY_MAP)() "}
{"text": "  from .._repository._abstract_converter import _AbstractConverter  from .._version._utils import _migrate_entity  from ..common._utils import _load_fct  from ..data._data_manager_factory import _DataManagerFactory  from ..exceptions import NonExistingDataNode  from ..task._task_model import _TaskModel  from ..task.task import Task  from .task import TaskId      class _TaskConverter(_AbstractConverter):      @classmethod      def _entity_to_model(cls, task: Task) -> _TaskModel:          return _TaskModel(              id=task.id,              owner_id=task.owner_id,              parent_ids=list(task._parent_ids),              config_id=task.config_id,              input_ids=cls.__to_ids(task.input.values()),              function_name=task._function.__name__,              function_module=task._function.__module__,              output_ids=cls.__to_ids(task.output.values()),              version=task._version,              skippable=task._skippable,              properties=task._properties.data.copy(),          )        @classmethod      def _model_to_entity(cls, model: _TaskModel) -> Task:          task = Task(              id=TaskId(model.id),              owner_id=model.owner_id,              parent_ids=set(model.parent_ids),              config_id=model.config_id,              function=_load_fct(model.function_module, model.function_name),              input=cls.__to_data_nodes(model.input_ids),              output=cls.__to_data_nodes(model.output_ids),              version=model.version,              skippable=model.skippable,              properties=model.properties,          )          return _migrate_entity(task)        @staticmethod      def __to_ids(data_nodes):          return [i.id for i in data_nodes]        @staticmethod      def __to_data_nodes(data_nodes_ids):          data_nodes = []          data_manager = _DataManagerFactory._build_manager()          for _id in data_nodes_ids:              if data_node := data_manager._get(_id):                  data_nodes.append(data_node)              else:                  raise NonExistingDataNode(_id)          return data_nodes "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._sql_repository import _SQLRepository  from ._task_converter import _TaskConverter  from ._task_model import _TaskModel      class _TaskSQLRepository(_SQLRepository):      def __init__(self):          super().__init__(model_type=_TaskModel, converter=_TaskConverter) "}
{"text": "from dataclasses import dataclass  from typing import Any, Dict, List, Optional    from sqlalchemy import JSON, Boolean, Column, String, Table    from .._repository._base_taipy_model import _BaseModel  from .._repository.db._sql_base_model import mapper_registry      @mapper_registry.mapped  @dataclass  class _TaskModel(_BaseModel):      __table__ = Table(          \"task\",          mapper_registry.metadata,          Column(\"id\", String, primary_key=True),          Column(\"owner_id\", String),          Column(\"parent_ids\", JSON),          Column(\"config_id\", String),          Column(\"input_ids\", JSON),          Column(\"function_name\", String),          Column(\"function_module\", String),          Column(\"output_ids\", JSON),          Column(\"version\", String),          Column(\"skippable\", Boolean),          Column(\"properties\", JSON),      )      id: str      owner_id: Optional[str]      parent_ids: List[str]      config_id: str      input_ids: List[str]      function_name: str      function_module: str      output_ids: List[str]      version: str      skippable: bool      properties: Dict[str, Any]        @staticmethod      def from_dict(data: Dict[str, Any]):          return _TaskModel(              id=data[\"id\"],              owner_id=data.get(\"owner_id\"),              parent_ids=_BaseModel._deserialize_attribute(data.get(\"parent_ids\", [])),              config_id=data[\"config_id\"],              input_ids=_BaseModel._deserialize_attribute(data[\"input_ids\"]),              function_name=data[\"function_name\"],              function_module=data[\"function_module\"],              output_ids=_BaseModel._deserialize_attribute(data[\"output_ids\"]),              version=data[\"version\"],              skippable=data[\"skippable\"],              properties=_BaseModel._deserialize_attribute(data[\"properties\"] if \"properties\" in data.keys() else {}),          )        def to_list(self):          return [              self.id,              self.owner_id,              _BaseModel._serialize_attribute(self.parent_ids),              self.config_id,              _BaseModel._serialize_attribute(self.input_ids),              self.function_name,              self.function_module,              _BaseModel._serialize_attribute(self.output_ids),              self.version,              self.skippable,              _BaseModel._serialize_attribute(self.properties),          ] "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._filesystem_repository import _FileSystemRepository  from ._task_converter import _TaskConverter  from ._task_model import _TaskModel      class _TaskFSRepository(_FileSystemRepository):      def __init__(self):          super().__init__(model_type=_TaskModel, converter=_TaskConverter, dir_name=\"tasks\") "}
{"text": "from typing import NewType    TaskId = NewType(\"TaskId\", str)  TaskId.__doc__ = \"\"\"Type that holds a `Task^` identifier.\"\"\" "}
{"text": "from dataclasses import dataclass  from typing import Any, Dict, List    from sqlalchemy import JSON, Boolean, Column, Enum, String, Table    from .._repository._base_taipy_model import _BaseModel  from .._repository.db._sql_base_model import mapper_registry  from .job_id import JobId  from .status import Status      @mapper_registry.mapped  @dataclass  class _JobModel(_BaseModel):      __table__ = Table(          \"job\",          mapper_registry.metadata,          Column(\"id\", String, primary_key=True),          Column(\"task_id\", String),          Column(\"status\", Enum(Status)),          Column(\"force\", Boolean),          Column(\"submit_id\", String),          Column(\"submit_entity_id\", String),          Column(\"creation_date\", String),          Column(\"subscribers\", JSON),          Column(\"stacktrace\", JSON),          Column(\"version\", String),      )      id: JobId      task_id: str      status: Status      force: bool      submit_id: str      submit_entity_id: str      creation_date: str      subscribers: List[Dict]      stacktrace: List[str]      version: str        @staticmethod      def from_dict(data: Dict[str, Any]):          return _JobModel(              id=data[\"id\"],              task_id=data[\"task_id\"],              status=Status._from_repr(data[\"status\"]),              force=data[\"force\"],              submit_id=data[\"submit_id\"],              submit_entity_id=data[\"submit_entity_id\"],              creation_date=data[\"creation_date\"],              subscribers=_BaseModel._deserialize_attribute(data[\"subscribers\"]),              stacktrace=_BaseModel._deserialize_attribute(data[\"stacktrace\"]),              version=data[\"version\"],          )        def to_list(self):          return [              self.id,              self.task_id,              repr(self.status),              self.force,              self.submit_id,              self.submit_entity_id,              self.creation_date,              _BaseModel._serialize_attribute(self.subscribers),              _BaseModel._serialize_attribute(self.stacktrace),              self.version,          ] "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._filesystem_repository import _FileSystemRepository  from ._job_converter import _JobConverter  from ._job_model import _JobModel      class _JobFSRepository(_FileSystemRepository):      def __init__(self):          super().__init__(model_type=_JobModel, converter=_JobConverter, dir_name=\"jobs\") "}
{"text": "import uuid  from typing import Callable, Iterable, List, Optional, Union    from .._manager._manager import _Manager  from .._repository._abstract_repository import _AbstractRepository  from .._version._version_manager_factory import _VersionManagerFactory  from .._version._version_mixin import _VersionMixin  from ..exceptions.exceptions import JobNotDeletedException  from ..notification import EventEntityType, EventOperation, Notifier, _make_event  from ..task.task import Task  from .job import Job  from .job_id import JobId      class _JobManager(_Manager[Job], _VersionMixin):      _ENTITY_NAME = Job.__name__      _ID_PREFIX = \"JOB_\"      _repository: _AbstractRepository      _EVENT_ENTITY_TYPE = EventEntityType.JOB        @classmethod      def _get_all(cls, version_number: Optional[str] = None) -> List[Job]:          \"\"\"          Returns all entities.          \"\"\"          filters = cls._build_filters_with_version(version_number)          return cls._repository._load_all(filters)        @classmethod      def _create(          cls, task: Task, callbacks: Iterable[Callable], submit_id: str, submit_entity_id: str, force=False      ) -> Job:          version = _VersionManagerFactory._build_manager()._get_latest_version()          job = Job(              id=JobId(f\"{Job._ID_PREFIX}_{task.config_id}_{uuid.uuid4()}\"),              task=task,              submit_id=submit_id,              submit_entity_id=submit_entity_id,              force=force,              version=version,          )          cls._set(job)          Notifier.publish(_make_event(job, EventOperation.CREATION))          job._on_status_change(*callbacks)          return job        @classmethod      def _delete(cls, job: Job, force=False):          if job.is_finished() or force:              super()._delete(job.id)              from .._orchestrator._dispatcher._job_dispatcher import _JobDispatcher                _JobDispatcher._pop_dispatched_process(job.id)          else:              err = JobNotDeletedException(job.id)              cls._logger.warning(err)              raise err        @classmethod      def _cancel(cls, job: Union[str, Job]):          job = cls._get(job) if isinstance(job, str) else job            from .._orchestrator._orchestrator_factory import _OrchestratorFactory            _OrchestratorFactory._build_orchestrator().cancel_job(job)        @classmethod      def _get_latest(cls, task: Task) -> Optional[Job]:          jobs_of_task = list(filter(lambda job: task in job, cls._get_all()))          if len(jobs_of_task) == 0:              return None          if len(jobs_of_task) == 1:              return jobs_of_task[0]          else:              return max(jobs_of_task)        @classmethod      def _is_deletable(cls, job: Union[Job, JobId]) -> bool:          if isinstance(job, str):              job = cls._get(job)          if job.is_finished():              return True          return False "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from typing import NewType    JobId = NewType(\"JobId\", str)  JobId.__doc__ = \"\"\"Type that holds a `Job^` identifier.\"\"\" "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._sql_repository import _SQLRepository  from ._job_converter import _JobConverter  from ._job_model import _JobModel      class _JobSQLRepository(_SQLRepository):      def __init__(self):          super().__init__(model_type=_JobModel, converter=_JobConverter) "}
{"text": "from datetime import datetime  from typing import List    from .._repository._abstract_converter import _AbstractConverter  from ..common._utils import _fcts_to_dict, _load_fct  from ..exceptions import InvalidSubscriber  from ..job._job_model import _JobModel  from ..job.job import Job  from ..task._task_manager_factory import _TaskManagerFactory      class _JobConverter(_AbstractConverter):      @classmethod      def _entity_to_model(cls, job: Job) -> _JobModel:          return _JobModel(              job.id,              job._task.id,              job._status,              job._force,              job.submit_id,              job.submit_entity_id,              job._creation_date.isoformat(),              cls.__serialize_subscribers(job._subscribers),              job._stacktrace,              version=job._version,          )        @classmethod      def _model_to_entity(cls, model: _JobModel) -> Job:          task_manager = _TaskManagerFactory._build_manager()          task_repository = task_manager._repository            job = Job(              id=model.id,              task=task_repository._load(model.task_id),              submit_id=model.submit_id,              submit_entity_id=model.submit_entity_id,              version=model.version,          )            job._status = model.status  # type: ignore          job._force = model.force  # type: ignore          job._creation_date = datetime.fromisoformat(model.creation_date)  # type: ignore          for it in model.subscribers:              try:                  fct_module, fct_name = it.get(\"fct_module\"), it.get(\"fct_name\")                  job._subscribers.append(_load_fct(fct_module, fct_name))  # type: ignore              except AttributeError:                  raise InvalidSubscriber(f\"The subscriber function {it.get('fct_name')} cannot be loaded.\")          job._stacktrace = model.stacktrace            return job        @staticmethod      def __serialize_subscribers(subscribers: List) -> List:          return _fcts_to_dict(subscribers) "}
{"text": "from ..common._repr_enum import _ReprEnum      class Status(_ReprEnum):      \"\"\"Execution status of a `Job^`.        It is implemented as an enumeration.        The possible values are:        - `SUBMITTED`: A `SUBMITTED` job has been submitted for execution but not processed yet by          the orchestrator.        - `PENDING`: A `PENDING` job has been enqueued by the orchestrator. It is waiting for an executor          to be available for its execution.        - `BLOCKED`: A `BLOCKED` job has been blocked because its input data nodes are not ready yet.          It is waiting for the completion of another `Job^`        - `RUNNING`: A `RUNNING` job is currently executed by a dedicated executor.        - `CANCELED`: A `CANCELED` job has been submitted but its execution has been canceled.        - `FAILED`: A `FAILED` job raised an exception during its execution.        - `COMPLETED`: A `COMPLETED` job has successfully been executed.        - `SKIPPED`: A `SKIPPED` job has not been executed because its outputs were already computed.        - `ABANDONED`: An `ABANDONED` job has not been executed because it depends on a job that could not complete (          cancelled, failed, or abandoned).      \"\"\"        SUBMITTED = 1      BLOCKED = 2      PENDING = 3      RUNNING = 4      CANCELED = 5      FAILED = 6      COMPLETED = 7      SKIPPED = 8      ABANDONED = 9 "}
{"text": "from typing import Type    from .._manager._manager_factory import _ManagerFactory  from ..common._utils import _load_fct  from ._job_fs_repository import _JobFSRepository  from ._job_manager import _JobManager  from ._job_sql_repository import _JobSQLRepository      class _JobManagerFactory(_ManagerFactory):        __REPOSITORY_MAP = {\"default\": _JobFSRepository, \"sql\": _JobSQLRepository}        @classmethod      def _build_manager(cls) -> Type[_JobManager]:  # type: ignore          if cls._using_enterprise():              job_manager = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".job._job_manager\", \"_JobManager\"              )  # type: ignore              build_repository = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".job._job_manager_factory\", \"_JobManagerFactory\"              )._build_repository  # type: ignore          else:              job_manager = _JobManager              build_repository = cls._build_repository          job_manager._repository = build_repository()  # type: ignore          return job_manager  # type: ignore        @classmethod      def _build_repository(cls):          return cls._get_repository_with_repo_map(cls.__REPOSITORY_MAP)() "}
{"text": "from typing import NewType    SequenceId = NewType(\"SequenceId\", str)  SequenceId.__doc__ = \"\"\"Type that holds a `Sequence^` identifier.\"\"\" "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from typing import Dict    from .._repository._abstract_converter import _AbstractConverter  from ..common import _utils  from ..task.task import Task  from .sequence import Sequence      class _SequenceConverter(_AbstractConverter):      _SEQUENCE_MODEL_ID_KEY = \"id\"      _SEQUENCE_MODEL_OWNER_ID_KEY = \"owner_id\"      _SEQUENCE_MODEL_PARENT_IDS_KEY = \"parent_ids\"      _SEQUENCE_MODEL_PROPERTIES_KEY = \"properties\"      _SEQUENCE_MODEL_TASKS_KEY = \"tasks\"      _SEQUENCE_MODEL_SUBSCRIBERS_KEY = \"subscribers\"      _SEQUENCE_MODEL_VERSION_KEY = \"version\"        @classmethod      def _entity_to_model(cls, sequence: Sequence) -> Dict:          return {              \"id\": sequence.id,              \"owner_id\": sequence.owner_id,              \"parent_ids\": list(sequence._parent_ids),              \"properties\": sequence._properties.data,              \"tasks\": cls.__to_task_ids(sequence._tasks),              \"subscribers\": _utils._fcts_to_dict(sequence._subscribers),              \"version\": sequence._version,          }        @staticmethod      def __to_task_ids(tasks):          return [t.id if isinstance(t, Task) else t for t in tasks] "}
{"text": "from typing import Type    from .._manager._manager_factory import _ManagerFactory  from ..common._utils import _load_fct  from ._sequence_manager import _SequenceManager      class _SequenceManagerFactory(_ManagerFactory):      @classmethod      def _build_manager(cls) -> Type[_SequenceManager]:  # type: ignore          if cls._using_enterprise():              sequence_manager = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".sequence._sequence_manager\", \"_SequenceManager\"              )  # type: ignore          else:              sequence_manager = _SequenceManager          return sequence_manager  # type: ignore "}
{"text": "from ..exceptions.exceptions import InvalidExposedType      class _AbstractTabularDataNode(object):      \"\"\"Abstract base class for tabular data node implementations (CSVDataNode, ParquetDataNode, ExcelDataNode,      SQLTableDataNode and SQLDataNode) that are tabular representable.\"\"\"        @staticmethod      def _check_exposed_type(exposed_type, valid_string_exposed_types):          if isinstance(exposed_type, str) and exposed_type not in valid_string_exposed_types:              raise InvalidExposedType(                  f\"Invalid string exposed type {exposed_type}. Supported values are \"                  f\"{', '.join(valid_string_exposed_types)}\"              ) "}
{"text": "from enum import Enum      class Operator(Enum):      \"\"\"Enumeration of operators for Data Node filtering.        The possible values are:        - `EQUAL`      - `NOT_EQUAL`      - `LESS_THAN`      - `LESS_OR_EQUAL`      - `GREATER_THAN`      - `GREATER_OR_EQUAL`      \"\"\"        EQUAL = 1      NOT_EQUAL = 2      LESS_THAN = 3      LESS_OR_EQUAL = 4      GREATER_THAN = 5      GREATER_OR_EQUAL = 6      class JoinOperator(Enum):      \"\"\"      Enumeration of join operators for Data Node filtering. The possible values are `AND` and `OR`.      \"\"\"        AND = 1      OR = 2 "}
{"text": "from .csv import CSVDataNode  from .data_node import DataNode  from .excel import ExcelDataNode  from .generic import GenericDataNode  from .in_memory import InMemoryDataNode  from .json import JSONDataNode  from .mongo import MongoCollectionDataNode  from .operator import JoinOperator, Operator  from .parquet import ParquetDataNode  from .pickle import PickleDataNode  from .sql import SQLDataNode  from .sql_table import SQLTableDataNode "}
{"text": "import pathlib      class _AbstractFileDataNode(object):      \"\"\"Abstract base class for data node implementations (CSVDataNode, ParquetDataNode, ExcelDataNode,      PickleDataNode and JSONDataNode) that are file based.\"\"\"        __EXTENSION_MAP = {\"csv\": \"csv\", \"excel\": \"xlsx\", \"parquet\": \"parquet\", \"pickle\": \"p\", \"json\": \"json\"}        def _build_path(self, storage_type):          from taipy.config.config import Config            folder = f\"{storage_type}s\"          dir_path = pathlib.Path(Config.core.storage_folder) / folder          if not dir_path.exists():              dir_path.mkdir(parents=True, exist_ok=True)          return dir_path / f\"{self.id}.{self.__EXTENSION_MAP.get(storage_type)}\" "}
{"text": "from typing import Type    from .._manager._manager_factory import _ManagerFactory  from ..common._utils import _load_fct  from ._data_fs_repository import _DataFSRepository  from ._data_manager import _DataManager  from ._data_sql_repository import _DataSQLRepository      class _DataManagerFactory(_ManagerFactory):        __REPOSITORY_MAP = {\"default\": _DataFSRepository, \"sql\": _DataSQLRepository}        @classmethod      def _build_manager(cls) -> Type[_DataManager]:  # type: ignore          if cls._using_enterprise():              data_manager = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".data._data_manager\", \"_DataManager\"              )  # type: ignore              build_repository = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".data._data_manager_factory\", \"_DataManagerFactory\"              )._build_repository  # type: ignore          else:              data_manager = _DataManager              build_repository = cls._build_repository          data_manager._repository = build_repository()  # type: ignore          return data_manager  # type: ignore        @classmethod      def _build_repository(cls):          return cls._get_repository_with_repo_map(cls.__REPOSITORY_MAP)() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._sql_repository import _SQLRepository  from ._data_converter import _DataNodeConverter  from ._data_model import _DataNodeModel      class _DataSQLRepository(_SQLRepository):      def __init__(self):          super().__init__(model_type=_DataNodeModel, converter=_DataNodeConverter) "}
{"text": "from dataclasses import dataclass  from typing import Any, Dict, List, Optional    from sqlalchemy import JSON, Boolean, Column, Enum, Float, String, Table, UniqueConstraint    from taipy.config.common.scope import Scope    from .._repository._base_taipy_model import _BaseModel  from .._repository.db._sql_base_model import mapper_registry  from .data_node_id import Edit      @mapper_registry.mapped  @dataclass  class _DataNodeModel(_BaseModel):      __table__ = Table(          \"data_node\",          mapper_registry.metadata,          Column(\"id\", String, primary_key=True),          Column(\"config_id\", String),          Column(\"scope\", Enum(Scope)),          Column(\"storage_type\", String),          Column(\"owner_id\", String),          Column(\"parent_ids\", JSON),          Column(\"last_edit_date\", String),          Column(\"edits\", JSON),          Column(\"version\", String),          Column(\"validity_days\", Float),          Column(\"validity_seconds\", Float),          Column(\"edit_in_progress\", Boolean),          Column(\"editor_id\", String),          Column(\"editor_expiration_date\", String),          Column(\"data_node_properties\", JSON),      )      __table_args__ = (UniqueConstraint(\"config_id\", \"owner_id\", name=\"_config_owner_uc\"),)        id: str      config_id: str      scope: Scope      storage_type: str      owner_id: Optional[str]      parent_ids: List[str]      last_edit_date: Optional[str]      edits: List[Edit]      version: str      validity_days: Optional[float]      validity_seconds: Optional[float]      edit_in_progress: bool      editor_id: Optional[str]      editor_expiration_date: Optional[str]      data_node_properties: Dict[str, Any]        @staticmethod      def from_dict(data: Dict[str, Any]):          return _DataNodeModel(              id=data[\"id\"],              config_id=data[\"config_id\"],              scope=Scope._from_repr(data[\"scope\"]),              storage_type=data[\"storage_type\"],              owner_id=data.get(\"owner_id\"),              parent_ids=data.get(\"parent_ids\", []),              last_edit_date=data.get(\"last_edit_date\"),              edits=_BaseModel._deserialize_attribute(data[\"edits\"]),              version=data[\"version\"],              validity_days=data[\"validity_days\"],              validity_seconds=data[\"validity_seconds\"],              edit_in_progress=bool(data.get(\"edit_in_progress\", False)),              editor_id=data.get(\"editor_id\", None),              editor_expiration_date=data.get(\"editor_expiration_date\"),              data_node_properties=_BaseModel._deserialize_attribute(data[\"data_node_properties\"]),          )        def to_list(self):          return [              self.id,              self.config_id,              repr(self.scope),              self.storage_type,              self.owner_id,              _BaseModel._serialize_attribute(self.parent_ids),              self.last_edit_date,              _BaseModel._serialize_attribute(self.edits),              self.version,              self.validity_days,              self.validity_seconds,              self.edit_in_progress,              self.editor_id,              self.editor_expiration_date,              _BaseModel._serialize_attribute(self.data_node_properties),          ] "}
{"text": "from datetime import datetime, timedelta  from typing import Any, Dict, List, Optional, Set    from taipy.config.common.scope import Scope    from .._version._version_manager_factory import _VersionManagerFactory  from .data_node import DataNode  from .data_node_id import DataNodeId, Edit    in_memory_storage: Dict[str, Any] = {}      class InMemoryDataNode(DataNode):      \"\"\"Data Node stored in memory.        Warning:          This Data Node implementation is not compatible with a parallel execution of taipy tasks,          but only with a task executor in development mode. The purpose of `InMemoryDataNode` is to be used          for development or debugging.        Attributes:          config_id (str): Identifier of the data node configuration. It must be a valid Python              identifier.          scope (Scope^): The scope of this data node.          id (str): The unique identifier of this data node.          owner_id (str): The identifier of the owner (sequence_id, scenario_id, cycle_id) or              `None`.          parent_ids (Optional[Set[str]]): The identifiers of the parent tasks or `None`.          last_edit_date (datetime): The date and time of the last modification.          edits (List[Edit^]): The ordered list of edits for that job.          version (str): The string indicates the application version of the data node to instantiate. If not provided,              the current version is used.          validity_period (Optional[timedelta]): The duration implemented as a timedelta since the last edit date for              which the data node can be considered up-to-date. Once the validity period has passed, the data node is              considered stale and relevant tasks will run even if they are skippable (see the              [Task management page](../core/entities/task-mgt.md) for more details).              If _validity_period_ is set to `None`, the data node is always up-to-date.          edit_in_progress (bool): True if a task computing the data node has been submitted              and not completed yet. False otherwise.          editor_id (Optional[str]): The identifier of the user who is currently editing the data node.          editor_expiration_date (Optional[datetime]): The expiration date of the editor lock.          properties (dict[str, Any]): A dictionary of additional properties. When creating an              _In Memory_ data node, if the _properties_ dictionary contains a _\"default_data\"_              entry, the data node is automatically written with the corresponding _\"default_data\"_              value.      \"\"\"        __STORAGE_TYPE = \"in_memory\"      __DEFAULT_DATA_VALUE = \"default_data\"      _REQUIRED_PROPERTIES: List[str] = []        def __init__(          self,          config_id: str,          scope: Scope,          id: Optional[DataNodeId] = None,          owner_id: Optional[str] = None,          parent_ids: Optional[Set[str]] = None,          last_edit_date: Optional[datetime] = None,          edits: List[Edit] = None,          version: str = None,          validity_period: Optional[timedelta] = None,          edit_in_progress: bool = False,          editor_id: Optional[str] = None,          editor_expiration_date: Optional[datetime] = None,          properties=None,      ):          if properties is None:              properties = {}          default_value = properties.pop(self.__DEFAULT_DATA_VALUE, None)          super().__init__(              config_id,              scope,              id,              owner_id,              parent_ids,              last_edit_date,              edits,              version or _VersionManagerFactory._build_manager()._get_latest_version(),              validity_period,              edit_in_progress,              editor_id,              editor_expiration_date,              **properties          )          if default_value is not None and self.id not in in_memory_storage:              self._write(default_value)              self._last_edit_date = datetime.now()              self._edits.append(                  Edit(                      {                          \"timestamp\": self._last_edit_date,                          \"writer_identifier\": \"TAIPY\",                          \"comments\": \"Default data written.\",                      }                  )              )            self._TAIPY_PROPERTIES.update({self.__DEFAULT_DATA_VALUE})        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        def _read(self):          return in_memory_storage.get(self.id)        def _write(self, data):          in_memory_storage[self.id] = data "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._filesystem_repository import _FileSystemRepository  from ._data_converter import _DataNodeConverter  from ._data_model import _DataNodeModel      class _DataFSRepository(_FileSystemRepository):      def __init__(self):          super().__init__(model_type=_DataNodeModel, converter=_DataNodeConverter, dir_name=\"data_nodes\") "}
{"text": "from typing import Any, Dict, NewType    DataNodeId = NewType(\"DataNodeId\", str)  DataNodeId.__doc__ = \"\"\"Type that holds a `DataNode^` identifier.\"\"\"  Edit = NewType(\"Edit\", Dict[str, Any])  Edit.__doc__ = \"\"\"Type that holds a `DataNode^` edit information.\"\"\" "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._filesystem_repository import _FileSystemRepository  from ._submission_converter import _SubmissionConverter  from ._submission_model import _SubmissionModel      class _SubmissionFSRepository(_FileSystemRepository):      def __init__(self):          super().__init__(model_type=_SubmissionModel, converter=_SubmissionConverter, dir_name=\"submission\") "}
{"text": "from typing import NewType    SubmissionId = NewType(\"SubmissionId\", str)  SubmissionId.__doc__ = \"\"\"Type that holds a `Submission^` identifier.\"\"\" "}
{"text": "from ..common._repr_enum import _ReprEnum      class SubmissionStatus(_ReprEnum):      \"\"\"Execution status of a `Submission^`.        It is implemented as an enumeration.        The possible values are:        - `SUBMITTED`: A `SUBMITTED` submission has been submitted for execution but not processed yet by          the orchestrator.        - `UNDEFINED`: AN `UNDEFINED` submission's jobs have been submitted for execution but got some undefined          status changes.        - `PENDING`: A `PENDING` submission has been enqueued by the orchestrator. It is waiting for an executor          to be available for its execution.        - `BLOCKED`: A `BLOCKED` submission has been blocked because it has been finished with a job being blocked.        - `RUNNING`: A `RUNNING` submission has its jobs currently being executed.        - `CANCELED`: A `CANCELED` submission has been submitted but its execution has been canceled.        - `FAILED`: A `FAILED` submission has a job failed during its execution.        - `COMPLETED`: A `COMPLETED` submission has successfully been executed.      \"\"\"        SUBMITTED = 0      UNDEFINED = 1      BLOCKED = 2      PENDING = 3      RUNNING = 4      CANCELED = 5      FAILED = 6      COMPLETED = 7 "}
{"text": "from dataclasses import dataclass  from typing import Any, Dict, List, Union    from sqlalchemy import JSON, Column, Enum, String, Table    from .._repository._base_taipy_model import _BaseModel  from .._repository.db._sql_base_model import mapper_registry  from ..job.job_id import JobId  from .submission_status import SubmissionStatus      @mapper_registry.mapped  @dataclass  class _SubmissionModel(_BaseModel):      __table__ = Table(          \"submission\",          mapper_registry.metadata,          Column(\"id\", String, primary_key=True),          Column(\"entity_id\", String),          Column(\"job_ids\", JSON),          Column(\"creation_date\", String),          Column(\"submission_status\", Enum(SubmissionStatus)),          Column(\"version\", String),      )      id: str      entity_id: str      job_ids: Union[List[JobId], List]      creation_date: str      submission_status: SubmissionStatus      version: str        @staticmethod      def from_dict(data: Dict[str, Any]):          return _SubmissionModel(              id=data[\"id\"],              entity_id=data[\"entity_id\"],              job_ids=_BaseModel._deserialize_attribute(data[\"job_ids\"]),              creation_date=data[\"creation_date\"],              submission_status=SubmissionStatus._from_repr(data[\"submission_status\"]),              version=data[\"version\"],          )        def to_list(self):          return [              self.id,              self.entity_id,              _BaseModel._serialize_attribute(self.job_ids),              self.creation_date,              repr(self.submission_status),              self.version,          ] "}
{"text": "from datetime import datetime    from .._repository._abstract_converter import _AbstractConverter  from ..job.job import Job, JobId  from ..submission._submission_model import _SubmissionModel  from ..submission.submission import Submission  from .submission import SubmissionId      class _SubmissionConverter(_AbstractConverter):      @classmethod      def _entity_to_model(cls, submission: Submission) -> _SubmissionModel:          return _SubmissionModel(              id=submission.id,              entity_id=submission._entity_id,              job_ids=[job.id if isinstance(job, Job) else JobId(str(job)) for job in list(submission._jobs)],              creation_date=submission._creation_date.isoformat(),              submission_status=submission._submission_status,              version=submission._version,          )        @classmethod      def _model_to_entity(cls, model: _SubmissionModel) -> Submission:          submission = Submission(              entity_id=model.entity_id,              id=SubmissionId(model.id),              jobs=model.job_ids,              creation_date=datetime.fromisoformat(model.creation_date),              submission_status=model.submission_status,              version=model.version,          )          return submission "}
{"text": "from typing import List, Optional, Union    from .._manager._manager import _Manager  from .._repository._abstract_repository import _AbstractRepository  from .._version._version_mixin import _VersionMixin  from ..notification import EventEntityType, EventOperation, Notifier, _make_event  from ..scenario.scenario import Scenario  from ..sequence.sequence import Sequence  from ..submission.submission import Submission  from ..task.task import Task      class _SubmissionManager(_Manager[Submission], _VersionMixin):      _ENTITY_NAME = Submission.__name__      _repository: _AbstractRepository      _EVENT_ENTITY_TYPE = EventEntityType.SUBMISSION        @classmethod      def _get_all(cls, version_number: Optional[str] = None) -> List[Submission]:          \"\"\"          Returns all entities.          \"\"\"          filters = cls._build_filters_with_version(version_number)          return cls._repository._load_all(filters)        @classmethod      def _create(          cls,          entity_id: str,      ) -> Submission:          submission = Submission(entity_id=entity_id)          cls._set(submission)            Notifier.publish(_make_event(submission, EventOperation.CREATION))            return submission        @classmethod      def _get_latest(cls, entity: Union[Scenario, Sequence, Task]) -> Optional[Submission]:          entity_id = entity.id if not isinstance(entity, str) else entity          submissions_of_task = list(filter(lambda submission: submission.entity_id == entity_id, cls._get_all()))          if len(submissions_of_task) == 0:              return None          if len(submissions_of_task) == 1:              return submissions_of_task[0]          else:              return max(submissions_of_task) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from typing import Type    from .._manager._manager_factory import _ManagerFactory  from ..common._utils import _load_fct  from ._submission_fs_repository import _SubmissionFSRepository  from ._submission_manager import _SubmissionManager  from ._submission_sql_repository import _SubmissionSQLRepository      class _SubmissionManagerFactory(_ManagerFactory):        __REPOSITORY_MAP = {\"default\": _SubmissionFSRepository, \"sql\": _SubmissionSQLRepository}        @classmethod      def _build_manager(cls) -> Type[_SubmissionManager]:  # type: ignore          if cls._using_enterprise():              submission_manager = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".submission._submission_manager\", \"_SubmissionManager\"              )  # type: ignore              build_repository = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".submission._submission_manager_factory\",                  \"_SubmissionManagerFactory\",              )._build_repository  # type: ignore          else:              submission_manager = _SubmissionManager              build_repository = cls._build_repository          submission_manager._repository = build_repository()  # type: ignore          return submission_manager  # type: ignore        @classmethod      def _build_repository(cls):          return cls._get_repository_with_repo_map(cls.__REPOSITORY_MAP)() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._sql_repository import _SQLRepository  from ._submission_converter import _SubmissionConverter  from ._submission_model import _SubmissionModel      class _SubmissionSQLRepository(_SQLRepository):      def __init__(self):          super().__init__(model_type=_SubmissionModel, converter=_SubmissionConverter) "}
{"text": "\"\"\"  A single-page Taipy application.    Please refer to https://docs.taipy.io/en/latest/manuals/gui/ for more details.  \"\"\"    import webbrowser    from taipy.gui import Markdown, notify  import taipy as tp    value = 0  logo = \"images/taipy_logo.jpg\"    page = Markdown(  \"\"\"  <center>  <|navbar|lov={[(\"page1\", \"Homepage\"), (\"https://docs.taipy.io/en/latest/manuals/about/\", \"Taipy Docs\"), (\"https://docs.taipy.io/en/latest/getting_started/\", \"Getting Started\")]}|>  </center>    <|  <center>      <|{logo}|image|height=200px|width=200px|on_action=image_action|>  </center>  |>    # Taipy Application    <|{value}|slider|on_change=on_slider|> <|Push|button|on_action=on_push|>  \"\"\"  )      def image_action(state):      webbrowser.open(\"https://taipy.io\")      def on_push(state):      ...      def on_slider(state):      if state.value == 100:          notify(state, \"success\", \"Taipy is running!\")      def on_change(state, var_name: str, var_value):      ...      gui = tp.Gui(page=page)    if __name__ == '__main__':      # Execute by the _Python_ interpretor, for debug only.      tp.run(gui, title=\"Taipy Application (development)\")  else:      # Execute by _Gunicorn_, for production environment.      app = tp.run(gui, title=\"Taipy Application\", run_server=False)"}
{"text": "from taipy import Gui    # A dark mode is available in Taipy  # However, we will use the light mode for the Getting Started  Gui(page=\"# Getting started with *Taipy*\").run(dark_mode=False)"}
{"text": ""}
{"text": ""}
{"text": "\"\"\"The setup script.\"\"\"      import json  import os  import sysconfig  from importlib.util import find_spec  from pathlib import Path    from setuptools import find_namespace_packages, find_packages, setup  from setuptools.command.build_py import build_py    with open(\"README.md\", \"rb\") as readme_file:      readme = readme_file.read().decode(\"UTF-8\")    with open(f\"src{os.sep}taipy{os.sep}version.json\") as version_file:      version = json.load(version_file)      version_string = f'{version.get(\"major\", 0)}.{version.get(\"minor\", 0)}.{version.get(\"patch\", 0)}'      if vext := version.get(\"ext\"):          version_string = f\"{version_string}.{vext}\"    requirements = [      \"backports.zoneinfo>=0.2.1,<0.3;python_version<'3.9'\",      \"cookiecutter>=2.1.1,<2.2\",      \"taipy-gui@git+https://git@github.com/Avaiga/taipy-gui.git@develop\",      \"taipy-rest@git+https://git@github.com/Avaiga/taipy-rest.git@develop\",      \"taipy-templates@git+https://git@github.com/Avaiga/taipy-templates.git@develop\",  ]    test_requirements = [\"pytest>=3.8\"]    extras_require = {      \"ngrok\": [\"pyngrok>=5.1,<6.0\"],      \"image\": [          \"python-magic>=0.4.24,<0.5;platform_system!='Windows'\",          \"python-magic-bin>=0.4.14,<0.5;platform_system=='Windows'\",      ],      \"rdp\": [\"rdp>=0.8\"],      \"arrow\": [\"pyarrow>=10.0.1,<11.0\"],      \"mssql\": [\"pyodbc>=4\"],  }      def _build_webapp():      already_exists = Path(\"./src/taipy/gui_core/lib/taipy-gui-core.js\").exists()      if not already_exists:          # default site-packages path is from the current python interpreter          site_packages_path = sysconfig.get_path(\"purelib\")          # taipy-gui should be available through setup_requires option          # taipy-gui at this step is installed in a backend site-packages separated from the one being used by pip          if find_spec(\"taipy\") and find_spec(\"taipy.gui\"):              import taipy                site_packages_path = Path(taipy.__file__).absolute().parent.parent            # Specify the correct path to taipy-gui in gui/.env file          env_file_path = Path(__file__).absolute().parent / \"frontend\" / \"taipy\" / \".env\"          if not os.path.exists(env_file_path):              with open(env_file_path, \"w\") as env_file:                  env_file.write(f\"TAIPY_GUI_DIR={site_packages_path}\\n\")          os.system(\"cd frontend/taipy && npm ci && npm run build\")      class NPMInstall(build_py):      def run(self):          _build_webapp()          build_py.run(self)      setup(      author=\"Avaiga\",      author_email=\"dev@taipy.io\",      python_requires=\">=3.8\",      classifiers=[          \"Intended Audience :: Developers\",          \"License :: OSI Approved :: Apache Software License\",          \"Natural Language :: English\",          \"Programming Language :: Python :: 3\",          \"Programming Language :: Python :: 3.8\",          \"Programming Language :: Python :: 3.9\",          \"Programming Language :: Python :: 3.10\",          \"Programming Language :: Python :: 3.11\",      ],      description=\"A 360\u00b0 open-source platform from Python pilots to production-ready web apps.\",      install_requires=requirements,      entry_points={          \"console_scripts\": [              \"taipy = taipy._entrypoint:_entrypoint\",          ]      },      license=\"Apache License 2.0\",      long_description=readme,      long_description_content_type=\"text/markdown\",      keywords=\"taipy\",      name=\"taipy\",      package_dir={\"\": \"src\"},      packages=find_namespace_packages(where=\"src\") + find_packages(include=[\"taipy\"]),      include_package_data=True,      test_suite=\"tests\",      url=\"https://github.com/avaiga/taipy\",      version=version_string,      zip_safe=False,      extras_require=extras_require,      cmdclass={\"build_py\": NPMInstall},  ) "}
{"text": "import re  import sys    repo_name = sys.argv[1]  branch_name = sys.argv[2]  # Regex pattern <img\\s+([^>]*?)(?<!['\"])(?<!\\/)src\\s*=\\s*(['\"])(?!http|\\/)(.*?)\\2([^>]*?)>  pattern = re.compile(\"<img\\\\s+([^>]*?)(?<!['\\\"])(?<!\\\\/)src\\\\s*=\\\\s*(['\\\"])(?!http|\\\\/)(.*?)\\\\2([^>]*?)>\")  replacement = r'<img \\1src=\"https://raw.githubusercontent.com/Avaiga/{repo_name}/{branch_name}/\\3\"\\4>'    with open(\"README.md\") as readme_file:      readme_str = readme_file.read()      modified_readme = re.sub(pattern, replacement.format(repo_name=repo_name, branch_name=branch_name), readme_str)    with open(\"README.md\", \"w\") as readme_file:      readme_file.write(modified_readme) "}
{"text": "# ############################################################  # Generate Python interface definition files  # ############################################################  from src.taipy.gui.config import Config  import json  import os  import typing as t    # ############################################################  # Generate gui pyi file (gui/gui.pyi)  # ############################################################  gui_py_file = \"./src/taipy/gui/gui.py\"  gui_pyi_file = gui_py_file + \"i\"    os.system(f\"pipenv run stubgen {gui_py_file} --no-import --parse-only --export-less -o ./\")      gui_config = \"\".join(      f\", {k}: {v.__name__} = ...\"      if \"<class\" in str(v)      else f\", {k}: {str(v).replace('typing', 't').replace('src.taipy.gui.config.', '')} = ...\"      for k, v in Config.__annotations__.items()  )    replaced_content = \"\"  with open(gui_pyi_file, \"r\") as file:      for line in file:          if \"def run(\" in line:              line = line.replace(                  \", run_server: bool = ..., run_in_thread: bool = ..., async_mode: str = ..., **kwargs\", gui_config              )          replaced_content = replaced_content + line    with open(gui_pyi_file, \"w\") as write_file:      write_file.write(replaced_content)    # ############################################################  # Generate Page Builder pyi file (gui/builder/__init__.pyi)  # ############################################################  builder_py_file = \"./src/taipy/gui/builder/__init__.py\"  builder_pyi_file = builder_py_file + \"i\"  with open(\"./src/taipy/gui/viselements.json\", \"r\") as file:      viselements = json.load(file)  with open(\"./tools/builder/block.txt\", \"r\") as file:      block_template = file.read()  with open(\"./tools/builder/control.txt\", \"r\") as file:      control_template = file.read()    os.system(f\"pipenv run stubgen {builder_py_file} --no-import --parse-only --export-less -o ./\")    with open(builder_pyi_file, \"a\") as file:      file.write(\"from ._element import _Element, _Block\\n\")      def get_properties(element, viselements) -> t.List[t.Dict[str, t.Any]]:      properties = element[\"properties\"]      if \"inherits\" not in element:          return properties      for inherit in element[\"inherits\"]:          inherit_element = next((e for e in viselements[\"undocumented\"] if e[0] == inherit), None)          if inherit_element is None:              inherit_element = next((e for e in viselements[\"blocks\"] if e[0] == inherit), None)          if inherit_element is None:              inherit_element = next((e for e in viselements[\"controls\"] if e[0] == inherit), None)          if inherit_element is None:              raise RuntimeError(f\"Can't find element with name {inherit}\")          properties += get_properties(inherit_element[1], viselements)      return properties      def build_doc(element: t.Dict[str, t.Any]):      if \"doc\" not in element:          return \"\"      doc = str(element[\"doc\"]).replace(\"\\n\", f'\\n{16*\" \"}')      return f\"{element['name']} ({element['type']}): {doc} {'(default: '+element['default_value'] + ')' if 'default_value' in element else ''}\"  # noqa: E501      for control_element in viselements[\"controls\"]:      name = control_element[0]      property_list = []      property_names = []      for property in get_properties(control_element[1], viselements):          if property[\"name\"] not in property_names and \"[\" not in property[\"name\"]:              property_list.append(property)              property_names.append(property[\"name\"])      properties = \", \".join([f\"{p} = ...\" for p in property_names])      doc_arguments = f\"\\n{12*' '}\".join([build_doc(p) for p in property_list])      # append properties to __init__.pyi      with open(builder_pyi_file, \"a\") as file:          file.write(              control_template.replace(\"{{name}}\", name)              .replace(\"{{properties}}\", properties)              .replace(\"{{doc_arguments}}\", doc_arguments)          )    for block_element in viselements[\"blocks\"]:      name = block_element[0]      property_list = []      property_names = []      for property in get_properties(block_element[1], viselements):          if property[\"name\"] not in property_names and \"[\" not in property[\"name\"]:              property_list.append(property)              property_names.append(property[\"name\"])      properties = \", \".join([f\"{p} = ...\" for p in property_names])      doc_arguments = f\"{8*' '}\".join([build_doc(p) for p in property_list])      # append properties to __init__.pyi      with open(builder_pyi_file, \"a\") as file:          file.write(              block_template.replace(\"{{name}}\", name)              .replace(\"{{properties}}\", properties)              .replace(\"{{doc_arguments}}\", doc_arguments)          )    os.system(f\"pipenv run isort {gui_pyi_file}\")  os.system(f\"pipenv run black {gui_pyi_file}\")  os.system(f\"pipenv run isort {builder_pyi_file}\")  os.system(f\"pipenv run black {builder_pyi_file}\") "}
{"text": "import pytest      def pytest_addoption(parser):      parser.addoption(\"--e2e-base-url\", action=\"store\", default=\"/\", help=\"base url for e2e testing\")      parser.addoption(\"--e2e-port\", action=\"store\", default=\"5000\", help=\"port for e2e testing\")      @pytest.fixture(scope=\"session\")  def e2e_base_url(request):      return request.config.getoption(\"--e2e-base-url\")      @pytest.fixture(scope=\"session\")  def e2e_port(request):      return request.config.getoption(\"--e2e-port\") "}
{"text": "from unittest import mock    from src.taipy._run import _run  from taipy.core import Core  from taipy.gui import Gui  from taipy.rest import Rest      @mock.patch(\"taipy.gui.Gui.run\")  def test_run_pass_with_gui(gui_run):      _run(Gui())      gui_run.assert_called_once()      @mock.patch(\"taipy.core.Core.run\")  def test_run_pass_with_core(core_run):      _run(Core())      core_run.assert_called_once()      @mock.patch(\"taipy.rest.Rest.run\")  @mock.patch(\"taipy.core.Core.run\")  def test_run_pass_with_rest(rest_run, core_run):      _run(Rest())      rest_run.assert_called_once()      core_run.assert_called_once()      @mock.patch(\"taipy.rest.Rest.run\")  @mock.patch(\"taipy.core.Core.run\")  def test_run_pass_with_core_and_rest(core_run, rest_run):      _run(Core(), Rest())      core_run.assert_called_once()      rest_run.assert_called_once()      @mock.patch(\"taipy.gui.Gui.run\")  @mock.patch(\"taipy.rest.Rest.run\")  @mock.patch(\"taipy.core.Core.run\")  def test_run_pass_with_gui_and_rest(core_run, rest_run, gui_run):      _run(Gui(), Rest())      gui_run.assert_called_once()      core_run.assert_called_once()      rest_run.assert_not_called()      @mock.patch(\"taipy.gui.Gui.run\")  @mock.patch(\"taipy.core.Core.run\")  def test_run_pass_with_gui_and_core(core_run, gui_run):      _run(Gui(), Core())      gui_run.assert_called_once()      core_run.assert_called_once() "}
{"text": "\"\"\"Unit test package for taipy.\"\"\" "}
{"text": "from unittest.mock import patch    import pytest    from src.taipy.core import Core  from src.taipy.core._orchestrator._dispatcher import _DevelopmentJobDispatcher, _StandaloneJobDispatcher  from src.taipy.core._orchestrator._orchestrator import _Orchestrator  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.exceptions.exceptions import CoreServiceIsAlreadyRunning  from taipy.config import Config  from taipy.config.exceptions.exceptions import ConfigurationUpdateBlocked      class TestCore:      def test_run_core_trigger_config_check(self, caplog):          Config.configure_data_node(id=\"d0\", storage_type=\"toto\")          with patch(\"sys.argv\", [\"prog\"]):              with pytest.raises(SystemExit):                  core = Core()                  core.run()          expected_error_message = (              \"`storage_type` field of DataNodeConfig `d0` must be either csv, sql_table,\"              \" sql, mongo_collection, pickle, excel, generic, json, parquet, or in_memory.\"              ' Current value of property `storage_type` is \"toto\".'          )          assert expected_error_message in caplog.text          core.stop()        def test_run_core_as_a_service_development_mode(self):          _OrchestratorFactory._dispatcher = None            with patch(\"sys.argv\", [\"prog\"]):              core = Core()              assert core._orchestrator is None              assert core._dispatcher is None              assert _OrchestratorFactory._dispatcher is None                core.run()              assert core._orchestrator is not None              assert core._orchestrator == _Orchestrator              assert _OrchestratorFactory._orchestrator is not None              assert _OrchestratorFactory._orchestrator == _Orchestrator              assert core._dispatcher is not None              assert isinstance(core._dispatcher, _DevelopmentJobDispatcher)              assert isinstance(_OrchestratorFactory._dispatcher, _DevelopmentJobDispatcher)              core.stop()        def test_run_core_as_a_service_standalone_mode(self):          _OrchestratorFactory._dispatcher = None            with patch(\"sys.argv\", [\"prog\"]):              core = Core()              assert core._orchestrator is None                assert core._dispatcher is None              assert _OrchestratorFactory._dispatcher is None                Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)              core.run()              assert core._orchestrator is not None              assert core._orchestrator == _Orchestrator              assert _OrchestratorFactory._orchestrator is not None              assert _OrchestratorFactory._orchestrator == _Orchestrator              assert core._dispatcher is not None              assert isinstance(core._dispatcher, _StandaloneJobDispatcher)              assert isinstance(_OrchestratorFactory._dispatcher, _StandaloneJobDispatcher)              assert core._dispatcher.is_running()              assert _OrchestratorFactory._dispatcher.is_running()              core.stop()        def test_core_service_can_only_be_run_once(self):          with patch(\"sys.argv\", [\"prog\"]):              core_instance_1 = Core()              core_instance_2 = Core()                core_instance_1.run()                with pytest.raises(CoreServiceIsAlreadyRunning):                  core_instance_1.run()              with pytest.raises(CoreServiceIsAlreadyRunning):                  core_instance_2.run()                # Stop the Core service and run it again should work              core_instance_1.stop()                core_instance_1.run()              core_instance_1.stop()              core_instance_2.run()              core_instance_2.stop()        def test_block_config_update_when_core_service_is_running_development_mode(self):          _OrchestratorFactory._dispatcher = None            with patch(\"sys.argv\", [\"prog\"]):              core = Core()              core.run()              with pytest.raises(ConfigurationUpdateBlocked):                  Config.configure_data_node(id=\"i1\")              core.stop()        def test_block_config_update_when_core_service_is_running_standalone_mode(self):          _OrchestratorFactory._dispatcher = None            with patch(\"sys.argv\", [\"prog\"]):              core = Core()              Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)              core.run()              with pytest.raises(ConfigurationUpdateBlocked):                  Config.configure_data_node(id=\"i1\")              core.stop() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import json  import os  from datetime import datetime, timedelta    import pytest    from src.taipy.core._repository._decoder import _Decoder  from src.taipy.core._repository._encoder import _Encoder      @pytest.fixture(scope=\"function\", autouse=True)  def create_and_delete_json_file():      test_json_file = {          \"name\": \"testing\",          \"date\": datetime(1991, 1, 1),          \"default_data\": \"data for testing encoder\",          \"validity_period\": timedelta(days=1),      }      with open(\"data.json\", \"w\") as f:          json.dump(test_json_file, f, ensure_ascii=False, indent=4, cls=_Encoder)      yield      os.unlink(\"data.json\")      def test_json_encoder():      with open(\"data.json\") as json_file:          data = json.load(json_file)          assert data[\"name\"] == \"testing\"          assert data[\"default_data\"] == \"data for testing encoder\"          assert data[\"date\"] == {              \"__type__\": \"Datetime\",              \"__value__\": \"1991-01-01T00:00:00\",          }          assert data[\"date\"].get(\"__type__\") == \"Datetime\"          assert data[\"date\"].get(\"__value__\") == \"1991-01-01T00:00:00\"      def test_json_decoder():      with open(\"data.json\") as json_file:          data = json.load(json_file, cls=_Decoder)          assert data[\"name\"] == \"testing\"          assert data[\"default_data\"] == \"data for testing encoder\"          assert data[\"date\"] == datetime(1991, 1, 1) "}
{"text": "import src.taipy.core.taipy as tp  from src.taipy.core.config import Config      def test_no_special_characters():      scenario_config = Config.configure_scenario(\"scenario_1\")        scenario = tp.create_scenario(scenario_config, name=\"martin\")      assert scenario.name == \"martin\"      scenarios = tp.get_scenarios()      assert len(scenarios) == 1      assert scenarios[0].name == \"martin\"      def test_many_special_characters():      scenario_config = Config.configure_scenario(\"scenario_1\")        special_characters = (          \"!#$%&'()*+,-./:;<=>?@[]^_`\\\\{\"          \"\u00bb\u00bc\u00bd\u00be\u00bf\u00c0\u00c1\u00c2\u00c3\u00c4\u00c5\u00c6\u00c7\u00c8\u00c9\u00ca\u00cb\u00cc\u00cd\u00ce\u00cf\u00d0\u00d1\u00d2\u00d3\u00d4\u00d5\u00d6\"          \"\u00d7\u00d8\u00d9\u00da\u00db\u00dc\u00dd\u00de\u00df\u00e0\u00e1\u00e2\u00e3\u00e4\u00e5\u00e6\u00e7\u00e8\u00e9\u00ea\u00eb\u00ec\u00ed\u00ee\u00ef\u00f0\u00f1\u00f2\"          \"\u00f3\u00f4\u00f5\u00f6\u00f7\u00f8\u00f9\u00fa\u00fb\u00fc\u00fd\u00fe\u00ff\u0100\u0101\u0102\u0103\u0104\u0105\u0106\u0107\u0108\u0109\u010a\u010b\u010c\u010d\u010e\"          \"\u010f\u0110\u0111\u0112\u0113\u0114\u0115\u0116\u0117\u0118\u0119\u011a\u011b\u011c\u011d\u011e\u011f\u0120\u0121\u0122\u0123\u0124\u0125\u0126\u0127\u0128\u0129\u012a\"          \"\u012b\u012c\u012d\u012e\u012f\u0130\u0132\u0133\u0134\u0135\u0136\u0137\u0138\u0139\u013a\u013b\u013c\u013d\u013e\u013f\u0140\u0141\u0142\u0143\u0144\u0145\u0146\u0147\"          \"\u0148\u0149\u014a\u014b\u014c\u014d\u014e\u014f\u0150\u0151\u0152\u0153\u0154\u0155\u0156\u0157\u0158\u0159\u015a\u015b\u015c\u015d\u015e\u015f\u0160\u0161\u0162\u0163\"          \"\u0164\u0165\u0166\u0167\u0168\u0169\u016a\u016b\u016c\u016d\u016e\u016f\u0170\u0171\u0172\u0173\u0174\u0175\u0176\u0177\u0178\u0179\u017a\u017b\u017c\u017d\u017e\u017f\"      )        scenario = tp.create_scenario(scenario_config, name=special_characters)      assert scenario.name == special_characters      scenarios = tp.get_scenarios()      assert len(scenarios) == 1      assert scenarios[0].name == special_characters "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import json  import os  import pathlib  import shutil    import pytest    from src.taipy.core.exceptions.exceptions import InvalidExportPath  from taipy.config.config import Config    from .mocks import MockConverter, MockFSRepository, MockModel, MockObj, MockSQLRepository      class TestRepositoriesStorage:      @pytest.mark.parametrize(          \"mock_repo,params\",          [              (MockFSRepository, {\"model_type\": MockModel, \"dir_name\": \"mock_model\", \"converter\": MockConverter}),              (MockSQLRepository, {\"model_type\": MockModel, \"converter\": MockConverter}),          ],      )      def test_save_and_fetch_model(self, mock_repo, params, init_sql_repo):          r = mock_repo(**params)          m = MockObj(\"uuid\", \"foo\")          r._save(m)            fetched_model = r._load(m.id)          assert m == fetched_model        @pytest.mark.parametrize(          \"mock_repo,params\",          [              (MockFSRepository, {\"model_type\": MockModel, \"dir_name\": \"mock_model\", \"converter\": MockConverter}),              (MockSQLRepository, {\"model_type\": MockModel, \"converter\": MockConverter}),          ],      )      def test_exists(self, mock_repo, params, init_sql_repo):          r = mock_repo(**params)          m = MockObj(\"uuid\", \"foo\")          r._save(m)            assert r._exists(m.id)          assert not r._exists(\"not-existed-model\")        @pytest.mark.parametrize(          \"mock_repo,params\",          [              (MockFSRepository, {\"model_type\": MockModel, \"dir_name\": \"mock_model\", \"converter\": MockConverter}),              (MockSQLRepository, {\"model_type\": MockModel, \"converter\": MockConverter}),          ],      )      def test_get_all(self, mock_repo, params, init_sql_repo):          objs = []          r = mock_repo(**params)          r._delete_all()            for i in range(5):              m = MockObj(f\"uuid-{i}\", f\"Foo{i}\")              objs.append(m)              r._save(m)          _objs = r._load_all()            assert len(_objs) == 5            for obj in _objs:              assert isinstance(obj, MockObj)          assert sorted(objs, key=lambda o: o.id) == sorted(_objs, key=lambda o: o.id)        @pytest.mark.parametrize(          \"mock_repo,params\",          [              (MockFSRepository, {\"model_type\": MockModel, \"dir_name\": \"mock_model\", \"converter\": MockConverter}),              (MockSQLRepository, {\"model_type\": MockModel, \"converter\": MockConverter}),          ],      )      def test_delete_all(self, mock_repo, params, init_sql_repo):          r = mock_repo(**params)          r._delete_all()            for i in range(5):              m = MockObj(f\"uuid-{i}\", f\"Foo{i}\")              r._save(m)            _models = r._load_all()          assert len(_models) == 5            r._delete_all()          _models = r._load_all()          assert len(_models) == 0        @pytest.mark.parametrize(          \"mock_repo,params\",          [              (MockFSRepository, {\"model_type\": MockModel, \"dir_name\": \"mock_model\", \"converter\": MockConverter}),              (MockSQLRepository, {\"model_type\": MockModel, \"converter\": MockConverter}),          ],      )      def test_delete_many(self, mock_repo, params, init_sql_repo):          r = mock_repo(**params)          r._delete_all()            for i in range(5):              m = MockObj(f\"uuid-{i}\", f\"Foo{i}\")              r._save(m)            _models = r._load_all()          assert len(_models) == 5          r._delete_many([\"uuid-0\", \"uuid-1\"])          _models = r._load_all()          assert len(_models) == 3        @pytest.mark.parametrize(          \"mock_repo,params\",          [              (MockFSRepository, {\"model_type\": MockModel, \"dir_name\": \"mock_model\", \"converter\": MockConverter}),              (MockSQLRepository, {\"model_type\": MockModel, \"converter\": MockConverter}),          ],      )      def test_search(self, mock_repo, params, init_sql_repo):          r = mock_repo(**params)          r._delete_all()            m = MockObj(\"uuid\", \"foo\")          r._save(m)            m1 = r._search(\"name\", \"bar\")          m2 = r._search(\"name\", \"foo\")            assert m1 == []          assert m2 == [m]        @pytest.mark.parametrize(          \"mock_repo,params\",          [              (MockFSRepository, {\"model_type\": MockModel, \"dir_name\": \"mock_model\", \"converter\": MockConverter}),              (MockSQLRepository, {\"model_type\": MockModel, \"converter\": MockConverter}),          ],      )      @pytest.mark.parametrize(\"export_path\", [\"tmp\"])      def test_export(self, mock_repo, params, export_path, init_sql_repo):          r = mock_repo(**params)            m = MockObj(\"uuid\", \"foo\")          r._save(m)            r._export(\"uuid\", export_path)          assert pathlib.Path(os.path.join(export_path, \"mock_model/uuid.json\")).exists()          with open(os.path.join(export_path, \"mock_model/uuid.json\"), \"r\") as exported_file:              exported_data = json.load(exported_file)              assert exported_data[\"id\"] == \"uuid\"              assert exported_data[\"name\"] == \"foo\"            # Export to same location again should work          r._export(\"uuid\", export_path)          assert pathlib.Path(os.path.join(export_path, \"mock_model/uuid.json\")).exists()            if mock_repo == MockFSRepository:              with pytest.raises(InvalidExportPath):                  r._export(\"uuid\", Config.core.storage_folder)            shutil.rmtree(export_path, ignore_errors=True) "}
{"text": "import dataclasses  import pathlib  from dataclasses import dataclass  from typing import Any, Dict, Optional    from sqlalchemy import Column, String, Table  from sqlalchemy.dialects import sqlite  from sqlalchemy.orm import declarative_base, registry  from sqlalchemy.schema import CreateTable    from src.taipy.core._repository._abstract_converter import _AbstractConverter  from src.taipy.core._repository._filesystem_repository import _FileSystemRepository  from src.taipy.core._repository._sql_repository import _SQLRepository  from src.taipy.core._version._version_manager import _VersionManager  from taipy.config.config import Config      class Base:      __allow_unmapped__ = True      Base = declarative_base(cls=Base)  # type: ignore  mapper_registry = registry()      @dataclass  class MockObj:      def __init__(self, id: str, name: str, version: Optional[str] = None) -> None:          self.id = id          self.name = name          if version:              self._version = version          else:              self._version = _VersionManager._get_latest_version()      @dataclass  class MockModel(Base):  # type: ignore      __table__ = Table(          \"mock_model\",          mapper_registry.metadata,          Column(\"id\", String(200), primary_key=True),          Column(\"name\", String(200)),          Column(\"version\", String(200)),      )      id: str      name: str      version: str        def to_dict(self):          return dataclasses.asdict(self)        @staticmethod      def from_dict(data: Dict[str, Any]):          return MockModel(id=data[\"id\"], name=data[\"name\"], version=data[\"version\"])        def _to_entity(self):          return MockObj(id=self.id, name=self.name, version=self.version)        @classmethod      def _from_entity(cls, entity: MockObj):          return MockModel(id=entity.id, name=entity.name, version=entity._version)        def to_list(self):          return [self.id, self.name, self.version]      class MockConverter(_AbstractConverter):      @classmethod      def _entity_to_model(cls, entity):          return MockModel(id=entity.id, name=entity.name, version=entity._version)        @classmethod      def _model_to_entity(cls, model):          return MockObj(id=model.id, name=model.name, version=model.version)      class MockFSRepository(_FileSystemRepository):      def __init__(self, **kwargs):          super().__init__(**kwargs)        @property      def _storage_folder(self) -> pathlib.Path:          return pathlib.Path(Config.core.storage_folder)  # type: ignore      class MockSQLRepository(_SQLRepository):      def __init__(self, **kwargs):          super().__init__(**kwargs)          self.db.execute(str(CreateTable(MockModel.__table__, if_not_exists=True).compile(dialect=sqlite.dialect()))) "}
{"text": "import pytest    from taipy.config.config import Config      def test_job_config():      assert Config.job_config.mode == \"development\"        job_c = Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)      assert job_c.mode == \"standalone\"      assert job_c.max_nb_of_workers == 2        assert Config.job_config.mode == \"standalone\"      assert Config.job_config.max_nb_of_workers == 2        Config.configure_job_executions(foo=\"bar\")      assert Config.job_config.foo == \"bar\"      def test_clean_config():      job_config = Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2, prop=\"foo\")        assert Config.job_config is job_config        job_config._clean()        # Check if the instance before and after _clean() is the same      assert Config.job_config is job_config        assert job_config.mode == \"development\"      assert job_config._config == {\"max_nb_of_workers\": 1}      assert job_config.properties == {} "}
{"text": "from taipy.config.config import Config      def migrate_pickle_path(dn):      dn.path = \"s1.pkl\"      def migrate_skippable(task):      task.skippable = True      def test_migration_config():      assert Config.migration_functions.migration_fcts == {}        data_nodes1 = Config.configure_data_node(\"data_nodes1\", \"pickle\")        migration_cfg = Config.add_migration_function(          target_version=\"1.0\",          config=data_nodes1,          migration_fct=migrate_pickle_path,      )        assert migration_cfg.migration_fcts == {\"1.0\": {\"data_nodes1\": migrate_pickle_path}}      assert migration_cfg.properties == {}        data_nodes2 = Config.configure_data_node(\"data_nodes2\", \"pickle\")        migration_cfg = Config.add_migration_function(          target_version=\"1.0\",          config=data_nodes2,          migration_fct=migrate_pickle_path,      )      assert migration_cfg.migration_fcts == {          \"1.0\": {\"data_nodes1\": migrate_pickle_path, \"data_nodes2\": migrate_pickle_path}      }      def test_clean_config():      assert Config.migration_functions.migration_fcts == {}        data_nodes1 = Config.configure_data_node(\"data_nodes1\", \"pickle\")      migration_cfg = Config.add_migration_function(          target_version=\"1.0\",          config=data_nodes1,          migration_fct=migrate_pickle_path,      )        assert migration_cfg.migration_fcts == {\"1.0\": {\"data_nodes1\": migrate_pickle_path}}      assert migration_cfg.properties == {}        migration_cfg._clean()        assert migration_cfg.migration_fcts == {}      assert migration_cfg._properties == {} "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from src.taipy.core.config import CoreSection  from src.taipy.core.config.data_node_config import DataNodeConfig  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.config.migration_config import MigrationConfig  from src.taipy.core.config.scenario_config import ScenarioConfig  from src.taipy.core.config.task_config import TaskConfig  from taipy.config._config import _Config  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from taipy.config.global_app.global_app_config import GlobalAppConfig      def _test_default_job_config(job_config: JobConfig):      assert job_config is not None      assert job_config.mode == JobConfig._DEFAULT_MODE      def _test_default_core_section(core_section: CoreSection):      assert core_section is not None      assert core_section.mode == CoreSection._DEFAULT_MODE      assert core_section.version_number == \"\"      assert not core_section.force      assert core_section.root_folder == \"./taipy/\"      assert core_section.storage_folder == \".data/\"      assert core_section.repository_type == \"filesystem\"      assert core_section.repository_properties == {}      assert len(core_section.properties) == 0      def _test_default_data_node_config(dn_config: DataNodeConfig):      assert dn_config is not None      assert dn_config.id is not None      assert dn_config.storage_type == \"pickle\"      assert dn_config.scope == Scope.SCENARIO      assert dn_config.validity_period is None      assert len(dn_config.properties) == 0  # type: ignore      def _test_default_task_config(task_config: TaskConfig):      assert task_config is not None      assert task_config.id is not None      assert task_config.input_configs == []      assert task_config.output_configs == []      assert task_config.function is None      assert not task_config.skippable      assert len(task_config.properties) == 0  # type: ignore      def _test_default_scenario_config(scenario_config: ScenarioConfig):      assert scenario_config is not None      assert scenario_config.id is not None      assert scenario_config.tasks == []      assert scenario_config.task_configs == []      assert scenario_config.additional_data_nodes == []      assert scenario_config.additional_data_node_configs == []      assert scenario_config.data_nodes == []      assert scenario_config.data_node_configs == []      assert scenario_config.sequences == {}      assert len(scenario_config.properties) == 0  # type: ignore      def _test_default_version_migration_config(version_migration_config: MigrationConfig):      assert version_migration_config is not None      assert version_migration_config.migration_fcts == {}      assert len(version_migration_config.properties) == 0  # type: ignore      def _test_default_global_app_config(global_config: GlobalAppConfig):      assert global_config is not None      assert not global_config.notification      assert len(global_config.properties) == 0      def test_default_configuration():      default_config = Config._default_config      assert default_config._global_config is not None      _test_default_global_app_config(default_config._global_config)      _test_default_global_app_config(Config.global_config)      _test_default_global_app_config(GlobalAppConfig().default_config())        assert default_config._unique_sections is not None      assert len(default_config._unique_sections) == 3      assert len(default_config._sections) == 3        _test_default_job_config(default_config._unique_sections[JobConfig.name])      _test_default_job_config(Config.job_config)      _test_default_job_config(JobConfig().default_config())        _test_default_version_migration_config(default_config._unique_sections[MigrationConfig.name])      _test_default_version_migration_config(Config.migration_functions)      _test_default_version_migration_config(MigrationConfig.default_config())        _test_default_core_section(default_config._unique_sections[CoreSection.name])      _test_default_core_section(Config.core)      _test_default_core_section(CoreSection().default_config())        _test_default_data_node_config(default_config._sections[DataNodeConfig.name][_Config.DEFAULT_KEY])      _test_default_data_node_config(Config.data_nodes[_Config.DEFAULT_KEY])      _test_default_data_node_config(DataNodeConfig.default_config())      assert len(default_config._sections[DataNodeConfig.name]) == 1      assert len(Config.data_nodes) == 1        _test_default_task_config(default_config._sections[TaskConfig.name][_Config.DEFAULT_KEY])      _test_default_task_config(Config.tasks[_Config.DEFAULT_KEY])      _test_default_task_config(TaskConfig.default_config())      assert len(default_config._sections[TaskConfig.name]) == 1      assert len(Config.tasks) == 1        _test_default_scenario_config(default_config._sections[ScenarioConfig.name][_Config.DEFAULT_KEY])      Config.scenarios[_Config.DEFAULT_KEY]      _test_default_scenario_config(Config.scenarios[_Config.DEFAULT_KEY])      _test_default_scenario_config(ScenarioConfig.default_config())      assert len(default_config._sections[ScenarioConfig.name]) == 1      assert len(Config.scenarios) == 1 "}
{"text": "from unittest.mock import patch    import pytest    from src.taipy.core._init_version import _read_version  from src.taipy.core.config.core_section import CoreSection  from src.taipy.core.exceptions import ConfigCoreVersionMismatched  from taipy.config.config import Config  from tests.core.utils.named_temporary_file import NamedTemporaryFile    _MOCK_CORE_VERSION = \"3.1.1\"      @pytest.fixture(scope=\"function\", autouse=True)  def mock_core_version():      with patch(\"src.taipy.core.config.core_section._read_version\") as mock_read_version:          mock_read_version.return_value = _MOCK_CORE_VERSION          CoreSection._CURRENT_CORE_VERSION = _MOCK_CORE_VERSION          Config.unique_sections[CoreSection.name] = CoreSection.default_config()          Config._default_config._unique_sections[CoreSection.name] = CoreSection.default_config()            yield      @pytest.fixture(scope=\"session\", autouse=True)  def reset_core_version():      yield      CoreSection._CURRENT_CORE_VERSION = _read_version()      class TestCoreVersionInCoreSectionConfig:      major, minor, patch = _MOCK_CORE_VERSION.split(\".\")        current_version = f\"{major}.{minor}.{patch}\"      current_dev_version = f\"{major}.{minor}.{patch}.dev0\"      compatible_future_version = f\"{major}.{minor}.{int(patch) + 1}\"      compatible_future_dev_version = f\"{major}.{minor}.{int(patch) + 1}.dev0\"        core_version_is_compatible = [          # Current version and dev version should be compatible          (f\"{major}.{minor}.{patch}\", True),          (f\"{major}.{minor}.{patch}.dev0\", True),          # Future versions with same major and minor should be compatible          (f\"{major}.{minor}.{int(patch) + 1}\", True),          (f\"{major}.{minor}.{int(patch) + 1}.dev0\", True),          # Past versions with same major and minor should be compatible          (f\"{major}.{minor}.{int(patch) - 1}\", True),          (f\"{major}.{minor}.{int(patch) - 1}.dev0\", True),          # Future versions with different minor number should be incompatible          (f\"{major}.{int(minor) + 1}.{patch}\", False),          (f\"{major}.{int(minor) + 1}.{patch}.dev0\", False),          # Past versions with different minor number should be incompatible          (f\"{major}.{int(minor) - 1}.{patch}\", False),          (f\"{major}.{int(minor) - 1}.{patch}.dev0\", False),      ]        @pytest.mark.parametrize(\"core_version, is_compatible\", core_version_is_compatible)      def test_load_configuration_file(self, core_version, is_compatible):          file_config = NamedTemporaryFile(              f\"\"\"              [TAIPY]                [JOB]              mode = \"standalone\"              max_nb_of_workers = \"2:int\"                [CORE]              root_folder = \"./taipy/\"              storage_folder = \".data/\"              repository_type = \"filesystem\"              read_entity_retry = \"0:int\"              mode = \"development\"              version_number = \"\"              force = \"False:bool\"              core_version = \"{core_version}\"                [VERSION_MIGRATION.migration_fcts]              \"\"\"          )          if is_compatible:              Config.load(file_config.filename)              assert Config.unique_sections[CoreSection.name]._core_version == _MOCK_CORE_VERSION          else:              with pytest.raises(ConfigCoreVersionMismatched):                  Config.load(file_config.filename)        @pytest.mark.parametrize(\"core_version,is_compatible\", core_version_is_compatible)      def test_override_configuration_file(self, core_version, is_compatible):          file_config = NamedTemporaryFile(              f\"\"\"              [TAIPY]                [JOB]              mode = \"standalone\"              max_nb_of_workers = \"2:int\"                [CORE]              root_folder = \"./taipy/\"              storage_folder = \".data/\"              repository_type = \"filesystem\"              read_entity_retry = \"0:int\"              mode = \"development\"              version_number = \"\"              force = \"False:bool\"              core_version = \"{core_version}\"                [VERSION_MIGRATION.migration_fcts]              \"\"\"          )          if is_compatible:              Config.override(file_config.filename)              assert Config.unique_sections[CoreSection.name]._core_version == _MOCK_CORE_VERSION          else:              with pytest.raises(ConfigCoreVersionMismatched):                  Config.override(file_config.filename)        def test_load_configuration_file_without_core_section(self):          file_config = NamedTemporaryFile(              \"\"\"              [TAIPY]              [JOB]              mode = \"standalone\"              max_nb_of_workers = \"2:int\"              [CORE]              root_folder = \"./taipy/\"              storage_folder = \".data/\"              repository_type = \"filesystem\"              read_entity_retry = \"0:int\"              mode = \"development\"              version_number = \"\"              force = \"False:bool\"              [VERSION_MIGRATION.migration_fcts]              \"\"\"          )          Config.load(file_config.filename)          assert Config.unique_sections[CoreSection.name]._core_version == _MOCK_CORE_VERSION "}
{"text": "from datetime import timedelta    from taipy.config import Config  from taipy.config.common.scope import Scope      class TestConfig:      def test_configure_csv_data_node(self):          a, b, c, d, e, f = \"foo\", \"path\", True, \"numpy\", Scope.SCENARIO, timedelta(1)          Config.configure_csv_data_node(a, b, c, d, e, f)          assert len(Config.data_nodes) == 2        def test_configure_excel_data_node(self):          a, b, c, d, e, f, g = \"foo\", \"path\", True, \"Sheet1\", \"numpy\", Scope.SCENARIO, timedelta(1)          Config.configure_excel_data_node(a, b, c, d, e, f, g)          assert len(Config.data_nodes) == 2        def test_configure_generic_data_node(self):          a, b, c, d, e, f, g, h = \"foo\", print, print, tuple([]), tuple([]), Scope.SCENARIO, timedelta(1), \"qux\"          Config.configure_generic_data_node(a, b, c, d, e, f, g, property=h)          assert len(Config.data_nodes) == 2        def test_configure_in_memory_data_node(self):          a, b, c, d, e = \"foo\", 0, Scope.SCENARIO, timedelta(1), \"qux\"          Config.configure_in_memory_data_node(a, b, c, d, property=e)          assert len(Config.data_nodes) == 2        def test_configure_pickle_data_node(self):          a, b, c, d, e = \"foo\", 0, Scope.SCENARIO, timedelta(1), \"path\"          Config.configure_pickle_data_node(a, b, c, d, path=e)          assert len(Config.data_nodes) == 2        def test_configure_json_data_node(self):          a, dp, ec, dc, sc, f, p = \"foo\", \"path\", \"ec\", \"dc\", Scope.SCENARIO, timedelta(1), \"qux\"          Config.configure_json_data_node(a, dp, ec, dc, sc, f, path=p)          assert len(Config.data_nodes) == 2        def test_configure_sql_table_data_node(self):          a, b, c, d, e, f, g, h, i, extra_args, exposed_type, scope, vp, k = (              \"foo\",              \"user\",              \"pwd\",              \"db\",              \"engine\",              \"table_name\",              \"port\",              \"host\",              \"driver\",              {\"foo\": \"bar\"},              \"exposed_type\",              Scope.SCENARIO,              timedelta(1),              \"qux\",          )          Config.configure_sql_table_data_node(a, b, c, d, e, f, g, h, i, extra_args, exposed_type, scope, vp, property=k)          assert len(Config.data_nodes) == 2        def test_configure_sql_data_node(self):          a, b, c, d, e, f, g, h, i, j, k, extra_args, exposed_type, scope, vp, k = (              \"foo\",              \"user\",              \"pwd\",              \"db\",              \"engine\",              \"read_query\",              \"write_query_builder\",              \"append_query_builder\",              \"port\",              \"host\",              \"driver\",              {\"foo\": \"bar\"},              \"exposed_type\",              Scope.SCENARIO,              timedelta(1),              \"qux\",          )          Config.configure_sql_data_node(a, b, c, d, e, f, g, h, i, j, k, extra_args, exposed_type, scope, vp, property=k)          assert len(Config.data_nodes) == 2        def test_configure_mongo_data_node(self):          a, b, c, d, e, f, g, h, extra_args, scope, vp, k = (              \"foo\",              \"db_name\",              \"collection_name\",              None,              \"user\",              \"pwd\",              \"host\",              \"port\",              {\"foo\": \"bar\"},              Scope.SCENARIO,              timedelta(1),              \"qux\",          )          Config.configure_mongo_collection_data_node(a, b, c, d, e, f, g, h, extra_args, scope, vp, property=k)          assert len(Config.data_nodes) == 2 "}
{"text": "from unittest.mock import patch    from src.taipy.core import Core  from src.taipy.core._version._version_manager_factory import _VersionManagerFactory  from taipy.config import Config  from tests.core.utils.named_temporary_file import NamedTemporaryFile      def test_core_section():      with patch(\"sys.argv\", [\"prog\"]):          core = Core()          core.run()      assert Config.core.mode == \"development\"      assert Config.core.version_number == _VersionManagerFactory._build_manager()._get_development_version()      assert not Config.core.force      core.stop()        with patch(\"sys.argv\", [\"prog\"]):          Config.configure_core(mode=\"experiment\", version_number=\"test_num\", force=True)          core = Core()          core.run()      assert Config.core.mode == \"experiment\"      assert Config.core.version_number == \"test_num\"      assert Config.core.force      core.stop()        toml_config = NamedTemporaryFile(          content=\"\"\"  [TAIPY]    [CORE]  mode = \"production\"  version_number = \"test_num_2\"  force = \"true:bool\"          \"\"\"      )      Config.load(toml_config.filename)      with patch(\"sys.argv\", [\"prog\"]):          core = Core()          core.run()      assert Config.core.mode == \"production\"      assert Config.core.version_number == \"test_num_2\"      assert Config.core.force      core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"test_num_3\", \"--no-taipy-force\"]):          core = Core()          core.run()          assert Config.core.mode == \"experiment\"          assert Config.core.version_number == \"test_num_3\"          assert not Config.core.force          core.stop()      def test_clean_config():      core_config = Config.configure_core(mode=\"experiment\", version_number=\"test_num\", force=True)        assert Config.core is core_config        core_config._clean()        # Check if the instance before and after _clean() is the same      assert Config.core is core_config        assert core_config.mode == \"development\"      assert core_config.version_number == \"\"        assert core_config.force is False      assert core_config.properties == {} "}
{"text": "from unittest.mock import patch    import pytest    from src.taipy.core import Core  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.config import MigrationConfig  from taipy.config.config import Config      def mock_func():      pass      def test_check_if_entity_property_key_used_is_predefined(caplog):      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()      assert caplog.text == \"\"      core.stop()        caplog.clear()        Config.unique_sections[MigrationConfig.name]._properties[\"_entity_owner\"] = None      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          with pytest.raises(SystemExit):              core = Core()              core.run()          core.stop()      assert (          \"Properties of MigrationConfig `VERSION_MIGRATION` cannot have `_entity_owner` as its property.\" in caplog.text      )        caplog.clear()        Config.unique_sections[MigrationConfig.name]._properties[\"_entity_owner\"] = \"entity_owner\"      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          with pytest.raises(SystemExit):              core = Core()              core.run()          core.stop()      expected_error_message = (          \"Properties of MigrationConfig `VERSION_MIGRATION` cannot have `_entity_owner` as its property.\"          ' Current value of property `_entity_owner` is \"entity_owner\".'      )      assert expected_error_message in caplog.text      def test_check_valid_version(caplog):      data_nodes1 = Config.configure_data_node(\"data_nodes1\", \"pickle\")        Config.add_migration_function(\"2.0\", data_nodes1, mock_func)      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          with pytest.raises(SystemExit):              core = Core()              core.run()          core.stop()      assert \"The target version for a migration function must be a production version.\" in caplog.text        caplog.clear()      Config.unblock_update()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()      assert caplog.text == \"\"      core.stop()      def test_check_callable_function(caplog):      data_nodes1 = Config.configure_data_node(\"data_nodes1\", \"pickle\")      Config.add_migration_function(\"1.0\", data_nodes1, 1)      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          with pytest.raises(SystemExit):              core = Core()              core.run()          core.stop()      expected_error_message = (          \"The migration function of config `data_nodes1` from version 1.0 must be populated with\"          \" Callable value. Current value of property `migration_fcts` is 1.\"      )      assert expected_error_message in caplog.text        caplog.clear()      Config.unblock_update()        Config.add_migration_function(\"1.0\", data_nodes1, \"bar\")      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          with pytest.raises(SystemExit):              core = Core()              core.run()          core.stop()      expected_error_message = (          \"The migration function of config `data_nodes1` from version 1.0 must be populated with\"          ' Callable value. Current value of property `migration_fcts` is \"bar\".'      )      assert expected_error_message in caplog.text        caplog.clear()      Config.unblock_update()        Config.add_migration_function(\"1.0\", data_nodes1, mock_func)      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()          core.stop()      def test_check_migration_from_productions_to_productions_exist(caplog):      _VersionManager._set_production_version(\"1.0\", True)      _VersionManager._set_production_version(\"1.1\", True)      _VersionManager._set_production_version(\"1.2\", True)        with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()          core.stop()      assert 'There is no migration function from production version \"1.0\" to version \"1.1\".' in caplog.text      assert 'There is no migration function from production version \"1.1\" to version \"1.2\".' in caplog.text        caplog.clear()      Config.unblock_update()        Config.add_migration_function(\"1.2\", \"data_nodes1\", mock_func)      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()          core.stop()      assert 'There is no migration function from production version \"1.0\" to version \"1.1\".' in caplog.text "}
{"text": "import pytest    from taipy.config.checker.issue_collector import IssueCollector  from taipy.config.config import Config      class TestConfigIdChecker:      def test_check_standalone_mode(self, caplog):          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            Config.configure_data_node(id=\"foo\", storage_type=\"in_memory\")          Config.configure_scenario(id=\"bar\", task_configs=[], additional_data_node_configs=[])            Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            Config.configure_data_node(id=\"bar\", task_configs=[])          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1            expected_error_message = (              \"`bar` is used as the config_id of multiple configurations ['DATA_NODE', 'SCENARIO']\"              ' Current value of property `config_id` is \"bar\".'          )          assert expected_error_message in caplog.text            Config.configure_task(id=\"bar\", function=print)          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"`bar` is used as the config_id of multiple configurations ['DATA_NODE', 'TASK', 'SCENARIO']\"              ' Current value of property `config_id` is \"bar\".'          )          assert expected_error_message in caplog.text            Config.configure_task(id=\"foo\", function=print)          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 2          expected_error_message = (              \"`foo` is used as the config_id of multiple configurations ['DATA_NODE', 'TASK']\"              ' Current value of property `config_id` is \"foo\".'          )          assert expected_error_message in caplog.text "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import pytest    from src.taipy.core.config.job_config import JobConfig  from taipy.config.checker.issue_collector import IssueCollector  from taipy.config.config import Config      class TestJobConfigChecker:      def test_check_standalone_mode(self, caplog):          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            Config.configure_data_node(id=\"foo\", storage_type=\"in_memory\")            Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE, max_nb_of_workers=2)          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=1)          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1            Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"DataNode `foo`: In-memory storage type can ONLY be used in development mode. Current\"              ' value of property `storage_type` is \"in_memory\".'          )          assert expected_error_message in caplog.text "}
{"text": "from src.taipy.core.config.checkers._core_section_checker import _CoreSectionChecker  from src.taipy.core.config.core_section import CoreSection  from taipy.config import Config  from taipy.config.checker.issue_collector import IssueCollector      class TestCoreSectionChecker:      _CoreSectionChecker._ACCEPTED_REPOSITORY_TYPES.update([\"mock_repo_type\"])        def test_check_valid_repository(self):          Config.configure_core(repository_type=\"mock_repo_type\")          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.warnings) == 0            Config.configure_core(repository_type=\"filesystem\")          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.warnings) == 0            Config.configure_core(repository_type=\"sql\")          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.warnings) == 0        def test_check_repository_type_value_wrong_str(self):          Config.configure_core(repository_type=\"any\")          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.warnings) == 1          assert Config._collector.warnings[0].field == CoreSection._REPOSITORY_TYPE_KEY          assert Config._collector.warnings[0].value == \"any\"        def test_check_repository_type_value_wrong_type(self):          Config.configure_core(repository_type=1)          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.warnings) == 1          assert Config._collector.warnings[0].field == CoreSection._REPOSITORY_TYPE_KEY          assert Config._collector.warnings[0].value == 1 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from queue import SimpleQueue    from src.taipy.core import taipy as tp  from src.taipy.core.notification.core_event_consumer import CoreEventConsumerBase  from src.taipy.core.notification.event import Event, EventEntityType, EventOperation  from src.taipy.core.notification.notifier import Notifier  from taipy.config import Config, Frequency  from tests.core.utils import assert_true_after_time      class AllCoreEventConsumerProcessor(CoreEventConsumerBase):      def __init__(self, registration_id: str, queue: SimpleQueue):          self.event_collected = 0          self.event_entity_type_collected: dict = {}          self.event_operation_collected: dict = {}          super().__init__(registration_id, queue)        def process_event(self, event: Event):          self.event_collected += 1          self.event_entity_type_collected[event.entity_type] = (              self.event_entity_type_collected.get(event.entity_type, 0) + 1          )          self.event_operation_collected[event.operation] = self.event_operation_collected.get(event.operation, 0) + 1      class ScenarioCoreEventConsumerProcessor(CoreEventConsumerBase):      def __init__(self, registration_id: str, queue: SimpleQueue):          self.scenario_event_collected = 0          self.event_operation_collected: dict = {}          super().__init__(registration_id, queue)        def process_event(self, event: Event):          self.scenario_event_collected += 1          self.event_operation_collected[event.operation] = self.event_operation_collected.get(event.operation, 0) + 1      class TaskCreationCoreEventConsumerProcessor(CoreEventConsumerBase):      def __init__(self, registration_id: str, queue: SimpleQueue):          self.task_event_collected = 0          self.creation_event_operation_collected = 0          super().__init__(registration_id, queue)        def process_event(self, event: Event):          self.task_event_collected += 1          self.creation_event_operation_collected += 1      def test_core_event_consumer():      register_id_0, register_queue_0 = Notifier.register()      all_evt_csumer_0 = AllCoreEventConsumerProcessor(register_id_0, register_queue_0)        register_id_1, register_queue_1 = Notifier.register(entity_type=EventEntityType.SCENARIO)      sc_evt_csumer_1 = ScenarioCoreEventConsumerProcessor(register_id_1, register_queue_1)        register_id_2, register_queue_2 = Notifier.register(          entity_type=EventEntityType.TASK, operation=EventOperation.CREATION      )      task_creation_evt_csumer_2 = TaskCreationCoreEventConsumerProcessor(register_id_2, register_queue_2)        all_evt_csumer_0.start()      sc_evt_csumer_1.start()      task_creation_evt_csumer_2.start()        dn_config = Config.configure_data_node(\"dn_config\")      task_config = Config.configure_task(\"task_config\", print, [dn_config])      scenario_config = Config.configure_scenario(          \"scenario_config\", [task_config], frequency=Frequency.DAILY, sequences={\"seq\": [task_config]}      )        # Create a scenario trigger 5 creation events      scenario = tp.create_scenario(scenario_config)      assert_true_after_time(lambda: all_evt_csumer_0.event_collected == 5, time=10)      assert_true_after_time(lambda: len(all_evt_csumer_0.event_entity_type_collected) == 5, time=10)      assert_true_after_time(lambda: all_evt_csumer_0.event_operation_collected[EventOperation.CREATION] == 5, time=10)      assert_true_after_time(lambda: sc_evt_csumer_1.scenario_event_collected == 1, time=10)      assert_true_after_time(lambda: sc_evt_csumer_1.event_operation_collected[EventOperation.CREATION] == 1, time=10)      assert_true_after_time(lambda: len(sc_evt_csumer_1.event_operation_collected) == 1, time=10)      assert_true_after_time(lambda: task_creation_evt_csumer_2.task_event_collected == 1, time=10)      assert_true_after_time(lambda: task_creation_evt_csumer_2.creation_event_operation_collected == 1, time=10)        # Delete a scenario trigger 5 update events      tp.delete(scenario.id)      assert_true_after_time(lambda: all_evt_csumer_0.event_collected == 10, time=10)      assert_true_after_time(lambda: len(all_evt_csumer_0.event_entity_type_collected) == 5, time=10)      assert_true_after_time(lambda: all_evt_csumer_0.event_operation_collected[EventOperation.DELETION] == 5, time=10)      assert_true_after_time(lambda: sc_evt_csumer_1.scenario_event_collected == 2, time=10)      assert_true_after_time(lambda: sc_evt_csumer_1.event_operation_collected[EventOperation.DELETION] == 1, time=10)      assert_true_after_time(lambda: len(sc_evt_csumer_1.event_operation_collected) == 2, time=10)      assert_true_after_time(lambda: task_creation_evt_csumer_2.task_event_collected == 1, time=10)      assert_true_after_time(lambda: task_creation_evt_csumer_2.creation_event_operation_collected == 1, time=10)        all_evt_csumer_0.stop()      sc_evt_csumer_1.stop()      task_creation_evt_csumer_2.stop() "}
{"text": "  from queue import SimpleQueue    from src.taipy.core.notification import EventEntityType, EventOperation  from src.taipy.core.notification._registration import _Registration  from src.taipy.core.notification._topic import _Topic      def test_create_registration():      registration_0 = _Registration()      assert isinstance(registration_0.registration_id, str)      assert registration_0.registration_id.startswith(_Registration._ID_PREFIX)      assert isinstance(registration_0.queue, SimpleQueue)      assert registration_0.queue.qsize() == 0      assert isinstance(registration_0.topic, _Topic)      assert registration_0.topic.entity_type is None      assert registration_0.topic.entity_id is None      assert registration_0.topic.operation is None      assert registration_0.topic.attribute_name is None        registration_1 = _Registration(          entity_type=EventEntityType.SCENARIO, entity_id=\"SCENARIO_scenario_id\", operation=EventOperation.CREATION      )      assert isinstance(registration_1.registration_id, str)      assert registration_1.registration_id.startswith(_Registration._ID_PREFIX)      assert isinstance(registration_1.queue, SimpleQueue)      assert registration_1.queue.qsize() == 0      assert isinstance(registration_1.topic, _Topic)      assert registration_1.topic.entity_type == EventEntityType.SCENARIO      assert registration_1.topic.entity_id == \"SCENARIO_scenario_id\"      assert registration_1.topic.operation == EventOperation.CREATION      assert registration_1.topic.attribute_name is None        registration_2 = _Registration(          entity_type=EventEntityType.SEQUENCE,          entity_id=\"SEQUENCE_scenario_id\",          operation=EventOperation.UPDATE,          attribute_name=\"tasks\",      )      assert isinstance(registration_2.registration_id, str)      assert registration_2.registration_id.startswith(_Registration._ID_PREFIX)      assert isinstance(registration_2.queue, SimpleQueue)      assert registration_2.queue.qsize() == 0      assert isinstance(registration_2.topic, _Topic)      assert registration_2.topic.entity_type == EventEntityType.SEQUENCE      assert registration_2.topic.entity_id == \"SEQUENCE_scenario_id\"      assert registration_2.topic.operation == EventOperation.UPDATE      assert registration_2.topic.attribute_name == \"tasks\" "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import os    import pytest    from src.taipy.core.cycle._cycle_fs_repository import _CycleFSRepository  from src.taipy.core.cycle._cycle_sql_repository import _CycleSQLRepository  from src.taipy.core.cycle.cycle import Cycle, CycleId  from src.taipy.core.exceptions import ModelNotFound      class TestCycleRepositories:      @pytest.mark.parametrize(\"repo\", [_CycleFSRepository, _CycleSQLRepository])      def test_save_and_load(self, cycle, repo, init_sql_repo):          repository = repo()          repository._save(cycle)            obj = repository._load(cycle.id)          assert isinstance(obj, Cycle)        @pytest.mark.parametrize(\"repo\", [_CycleFSRepository, _CycleSQLRepository])      def test_exists(self, cycle, repo, init_sql_repo):          repository = repo()          repository._save(cycle)            assert repository._exists(cycle.id)          assert not repository._exists(\"not-existed-cycle\")        @pytest.mark.parametrize(\"repo\", [_CycleFSRepository, _CycleSQLRepository])      def test_load_all(self, cycle, repo, init_sql_repo):          repository = repo()          for i in range(10):              cycle.id = CycleId(f\"cycle-{i}\")              repository._save(cycle)          data_nodes = repository._load_all()            assert len(data_nodes) == 10        @pytest.mark.parametrize(\"repo\", [_CycleFSRepository, _CycleSQLRepository])      def test_load_all_with_filters(self, cycle, repo, init_sql_repo):          repository = repo()            for i in range(10):              cycle.id = CycleId(f\"cycle-{i}\")              cycle._name = f\"cycle-{i}\"              repository._save(cycle)          objs = repository._load_all(filters=[{\"id\": \"cycle-2\"}])            assert len(objs) == 1        @pytest.mark.parametrize(\"repo\", [_CycleSQLRepository])      def test_delete(self, cycle, repo, init_sql_repo):          repository = repo()          repository._save(cycle)            repository._delete(cycle.id)            with pytest.raises(ModelNotFound):              repository._load(cycle.id)        @pytest.mark.parametrize(\"repo\", [_CycleFSRepository, _CycleSQLRepository])      def test_delete_all(self, cycle, repo, init_sql_repo):          repository = repo()            for i in range(10):              cycle.id = CycleId(f\"cycle-{i}\")              repository._save(cycle)            assert len(repository._load_all()) == 10            repository._delete_all()            assert len(repository._load_all()) == 0        @pytest.mark.parametrize(\"repo\", [_CycleFSRepository, _CycleSQLRepository])      def test_delete_many(self, cycle, repo, init_sql_repo):          repository = repo()            for i in range(10):              cycle.id = CycleId(f\"cycle-{i}\")              repository._save(cycle)            objs = repository._load_all()          assert len(objs) == 10          ids = [x.id for x in objs[:3]]          repository._delete_many(ids)            assert len(repository._load_all()) == 7        @pytest.mark.parametrize(\"repo\", [_CycleFSRepository, _CycleSQLRepository])      def test_search(self, cycle, repo, init_sql_repo):          repository = repo()            for i in range(10):              cycle.id = CycleId(f\"cycle-{i}\")              cycle.name = f\"cycle-{i}\"              repository._save(cycle)            assert len(repository._load_all()) == 10            objs = repository._search(\"name\", \"cycle-2\")          assert len(objs) == 1          assert isinstance(objs[0], Cycle)        @pytest.mark.parametrize(\"repo\", [_CycleFSRepository, _CycleSQLRepository])      def test_export(self, tmpdir, cycle, repo, init_sql_repo):          repository = repo()          repository._save(cycle)            repository._export(cycle.id, tmpdir.strpath)          dir_path = repository.dir_path if repo == _CycleFSRepository else os.path.join(tmpdir.strpath, \"cycle\")          assert os.path.exists(os.path.join(dir_path, f\"{cycle.id}.json\")) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import dataclasses  import pathlib  from dataclasses import dataclass  from typing import Any, Dict, Iterable, List, Optional, Union    from src.taipy.core._manager._manager import _Manager  from src.taipy.core._repository._abstract_converter import _AbstractConverter  from src.taipy.core._repository._abstract_repository import _AbstractRepository  from src.taipy.core._repository._filesystem_repository import _FileSystemRepository  from src.taipy.core._version._version_manager import _VersionManager  from taipy.config.config import Config      @dataclass  class MockModel:      id: str      name: str      version: str        def to_dict(self):          return dataclasses.asdict(self)        @staticmethod      def from_dict(data: Dict[str, Any]):          return MockModel(id=data[\"id\"], name=data[\"name\"], version=data[\"version\"])      @dataclass  class MockEntity:      def __init__(self, id: str, name: str, version: str = None) -> None:          self.id = id          self.name = name          if version:              self._version = version          else:              self._version = _VersionManager._get_latest_version()      class MockConverter(_AbstractConverter):      @classmethod      def _entity_to_model(cls, entity: MockEntity) -> MockModel:          return MockModel(id=entity.id, name=entity.name, version=entity._version)        @classmethod      def _model_to_entity(cls, model: MockModel) -> MockEntity:          return MockEntity(id=model.id, name=model.name, version=model.version)      class MockRepository(_AbstractRepository):  # type: ignore      def __init__(self, **kwargs):          self.repo = _FileSystemRepository(**kwargs, converter=MockConverter)        def _to_model(self, obj: MockEntity):          return MockModel(obj.id, obj.name, obj._version)        def _from_model(self, model: MockModel):          return MockEntity(model.id, model.name, model.version)        def _load(self, entity_id: str) -> MockEntity:          return self.repo._load(entity_id)        def _load_all(self, filters: Optional[List[Dict]] = None) -> List[MockEntity]:          return self.repo._load_all(filters)        def _save(self, entity: MockEntity):          return self.repo._save(entity)        def _exists(self, entity_id: str) -> bool:          return self.repo._exists(entity_id)        def _delete(self, entity_id: str):          return self.repo._delete(entity_id)        def _delete_all(self):          return self.repo._delete_all()        def _delete_many(self, ids: Iterable[str]):          return self.repo._delete_many(ids)        def _delete_by(self, attribute: str, value: str):          return self.repo._delete_by(attribute, value)        def _search(self, attribute: str, value: Any, filters: Optional[List[Dict]] = None) -> List[MockEntity]:          return self.repo._search(attribute, value, filters)        def _export(self, entity_id: str, folder_path: Union[str, pathlib.Path]):          return self.repo._export(self, entity_id, folder_path)        @property      def _storage_folder(self) -> pathlib.Path:          return pathlib.Path(Config.core.storage_folder)  # type: ignore      class MockManager(_Manager[MockEntity]):      _ENTITY_NAME = MockEntity.__name__      _repository = MockRepository(model_type=MockModel, dir_name=\"foo\")      class TestManager:      def test_save_and_fetch_model(self):          m = MockEntity(\"uuid\", \"foo\")          MockManager._set(m)            fetched_model = MockManager._get(m.id)          assert m == fetched_model        def test_exists(self):          m = MockEntity(\"uuid\", \"foo\")          MockManager._set(m)          assert MockManager._exists(m.id)        def test_get(self):          m = MockEntity(\"uuid\", \"foo\")          MockManager._set(m)          assert MockManager._get(m.id) == m        def test_get_all(self):          MockManager._delete_all()            objs = []          for i in range(5):              m = MockEntity(f\"uuid-{i}\", f\"Foo{i}\")              objs.append(m)              MockManager._set(m)          _objs = MockManager._get_all()            assert len(_objs) == 5        def test_delete(self):          m = MockEntity(\"uuid\", \"foo\")          MockManager._set(m)          MockManager._delete(m.id)          assert MockManager._get(m.id) is None        def test_delete_all(self):          objs = []          for i in range(5):              m = MockEntity(f\"uuid-{i}\", f\"Foo{i}\")              objs.append(m)              MockManager._set(m)          MockManager._delete_all()          assert MockManager._get_all() == []        def test_delete_many(self):          objs = []          for i in range(5):              m = MockEntity(f\"uuid-{i}\", f\"Foo{i}\")              objs.append(m)              MockManager._set(m)          MockManager._delete_many([\"uuid-0\", \"uuid-1\"])          assert len(MockManager._get_all()) == 3        def test_is_editable(self):          m = MockEntity(\"uuid\", \"Foo\")          MockManager._set(m)          assert MockManager._is_editable(m)        def test_is_readable(self):          m = MockEntity(\"uuid\", \"Foo\")          MockManager._set(m)          assert MockManager._is_readable(m) "}
{"text": "  class NotifyMock:      \"\"\"      A shared class for testing notification on jobStatus of sequence level and scenario level        \"entity\" can be understood as either \"scenario\" or \"sequence\".      \"\"\"        def __init__(self, entity):          self.scenario = entity          self.nb_called = 0          self.__name__ = \"NotifyMock\"        def __call__(self, entity, job):          assert entity == self.scenario          if self.nb_called == 0:              assert job.is_pending()          if self.nb_called == 1:              assert job.is_running()          if self.nb_called == 2:              assert job.is_finished()          self.nb_called += 1        def assert_called_3_times(self):          assert self.nb_called == 3        def assert_not_called(self):          assert self.nb_called == 0        def reset(self):          self.nb_called = 0 "}
{"text": "  def assert_true_after_time(assertion, msg=None, time=120):      from datetime import datetime      from time import sleep        loops = 0      start = datetime.now()      while (datetime.now() - start).seconds < time:          sleep(1)  # Limit CPU usage          try:              if assertion():                  return          except BaseException as e:              print(\"Raise : \", e)              loops += 1              continue      if msg:          print(msg)      assert assertion() "}
{"text": "import os  import tempfile      class NamedTemporaryFile:      def __init__(self, content=None):          with tempfile.NamedTemporaryFile(\"w\", delete=False) as fd:              if content:                  fd.write(content)              self.filename = fd.name        def read(self):          with open(self.filename, \"r\") as fp:              return fp.read()        def __del__(self):          os.unlink(self.filename) "}
{"text": "from unittest import mock    import pytest    from src.taipy.core import taipy  from src.taipy.core._entity._labeled import _Labeled  from taipy.config import Config, Frequency, Scope      class MockOwner:      label = \"owner_label\"        def get_label(self):          return self.label      def test_get_label():      labeled_entity = _Labeled()        with pytest.raises(NotImplementedError):          labeled_entity.get_label()        with pytest.raises(NotImplementedError):          labeled_entity.get_simple_label()        with pytest.raises(AttributeError):          labeled_entity._get_label()        with pytest.raises(AttributeError):          labeled_entity._get_simple_label()        labeled_entity.id = \"id\"      assert labeled_entity._get_label() == \"id\"      assert labeled_entity._get_simple_label() == \"id\"        labeled_entity.config_id = \"the config id\"      assert labeled_entity._get_label() == \"the config id\"      assert labeled_entity._get_simple_label() == \"the config id\"        labeled_entity._properties = {\"name\": \"a name\"}      assert labeled_entity._get_label() == \"a name\"      assert labeled_entity._get_simple_label() == \"a name\"        labeled_entity.owner_id = \"owner_id\"      with mock.patch(\"src.taipy.core.get\") as get_mck:          get_mck.return_value = MockOwner()          assert labeled_entity._get_label() == \"owner_label > a name\"          assert labeled_entity._get_simple_label() == \"a name\"            labeled_entity._properties[\"label\"] = \"a wonderful label\"          assert labeled_entity._get_label() == \"a wonderful label\"          assert labeled_entity._get_simple_label() == \"a wonderful label\"      def mult(n1, n2):      return n1 * n2      def test_get_label_complex_case():      dn1_cfg = Config.configure_data_node(\"dn1\", scope=Scope.GLOBAL)      dn2_cfg = Config.configure_data_node(\"dn2\", scope=Scope.CYCLE)      dn3_cfg = Config.configure_data_node(\"dn3\", scope=Scope.CYCLE)      dn4_cfg = Config.configure_data_node(\"dn4\", scope=Scope.SCENARIO)      dn5_cfg = Config.configure_data_node(\"dn5\", scope=Scope.SCENARIO)      tA_cfg = Config.configure_task(\"t_A_C\", mult, [dn1_cfg, dn2_cfg], dn3_cfg)      tB_cfg = Config.configure_task(\"t_B_S\", mult, [dn3_cfg, dn4_cfg], dn5_cfg)      scenario_cfg = Config.configure_scenario(\"scenario_cfg\", [tA_cfg, tB_cfg], [], Frequency.DAILY)      scenario_cfg.add_sequences(          {              \"sequence_C\": [tA_cfg],              \"sequence_S\": [tA_cfg, tB_cfg],          }      )        scenario = taipy.create_scenario(scenario_cfg, name=\"My Name\")      cycle = scenario.cycle      cycle.name = \"Today\"      sequence_C = scenario.sequence_C      sequence_S = scenario.sequence_S      tA = scenario.t_A_C      tB = scenario.t_B_S      dn1 = scenario.dn1      dn2 = scenario.dn2      dn3 = scenario.dn3      dn4 = scenario.dn4      dn5 = scenario.dn5        assert cycle.get_label() == scenario.cycle.name      assert cycle.get_simple_label() == scenario.cycle.name      assert scenario.get_label() == \"Today > My Name\"      assert scenario.get_simple_label() == \"My Name\"      assert sequence_C.get_label() == \"Today > My Name > sequence_C\"      assert sequence_C.get_simple_label() == \"sequence_C\"      assert sequence_S.get_label() == \"Today > My Name > sequence_S\"      assert sequence_S.get_simple_label() == \"sequence_S\"      assert tA.get_label() == \"Today > t_A_C\"      assert tA.get_simple_label() == \"t_A_C\"      assert tB.get_label() == \"Today > My Name > t_B_S\"      assert tB.get_simple_label() == \"t_B_S\"      assert dn1.get_label() == \"dn1\"      assert dn1.get_simple_label() == \"dn1\"      assert dn2.get_label() == \"Today > dn2\"      assert dn2.get_simple_label() == \"dn2\"      assert dn3.get_label() == \"Today > dn3\"      assert dn3.get_simple_label() == \"dn3\"      assert dn4.get_label() == \"Today > My Name > dn4\"      assert dn4.get_simple_label() == \"dn4\"      assert dn5.get_label() == \"Today > My Name > dn5\"      assert dn5.get_simple_label() == \"dn5\" "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from src.taipy.core._entity._entity_ids import _EntityIds      class TestEntityIds:      def test_add_two_entity_ids(self):          entity_ids_1 = _EntityIds()          entity_ids_2 = _EntityIds()            entity_ids_1_address = id(entity_ids_1)            entity_ids_1.data_node_ids.update([\"data_node_id_1\", \"data_node_id_2\"])          entity_ids_1.task_ids.update([\"task_id_1\", \"task_id_2\"])          entity_ids_1.job_ids.update([\"job_id_1\", \"job_id_2\"])          entity_ids_1.sequence_ids.update([\"sequence_id_1\", \"sequence_id_2\"])          entity_ids_1.scenario_ids.update([\"scenario_id_1\", \"scenario_id_2\"])          entity_ids_1.cycle_ids.update([\"cycle_id_1\", \"cycle_id_2\"])            entity_ids_2.data_node_ids.update([\"data_node_id_2\", \"data_node_id_3\"])          entity_ids_2.task_ids.update([\"task_id_2\", \"task_id_3\"])          entity_ids_2.job_ids.update([\"job_id_2\", \"job_id_3\"])          entity_ids_2.sequence_ids.update([\"sequence_id_2\", \"sequence_id_3\"])          entity_ids_2.scenario_ids.update([\"scenario_id_2\", \"scenario_id_3\"])          entity_ids_2.cycle_ids.update([\"cycle_id_2\", \"cycle_id_3\"])            entity_ids_1 += entity_ids_2            # += operator should not change the address of entity_ids_1          assert id(entity_ids_1) == entity_ids_1_address            assert entity_ids_1.data_node_ids == {\"data_node_id_1\", \"data_node_id_2\", \"data_node_id_3\"}          assert entity_ids_1.task_ids == {\"task_id_1\", \"task_id_2\", \"task_id_3\"}          assert entity_ids_1.job_ids == {\"job_id_1\", \"job_id_2\", \"job_id_3\"}          assert entity_ids_1.sequence_ids == {\"sequence_id_1\", \"sequence_id_2\", \"sequence_id_3\"}          assert entity_ids_1.scenario_ids == {\"scenario_id_1\", \"scenario_id_2\", \"scenario_id_3\"}          assert entity_ids_1.cycle_ids == {\"cycle_id_1\", \"cycle_id_2\", \"cycle_id_3\"} "}
{"text": "import pytest    from src.taipy.core.common._utils import _retry_read_entity  from taipy.config import Config      def test_retry_decorator(mocker):      func = mocker.Mock(side_effect=Exception())        @_retry_read_entity((Exception,))      def decorated_func():          func()        with pytest.raises(Exception):          decorated_func()      # Called once in the normal flow and no retry      # The Config.core.read_entity_retry is set to 0 at conftest.py      assert Config.core.read_entity_retry == 0      assert func.call_count == 1        func.reset_mock()        Config.core.read_entity_retry = 3      with pytest.raises(Exception):          decorated_func()      # Called once in the normal flow and 3 more times on the retry flow      assert func.call_count == 4      def test_retry_decorator_exception_not_in_list(mocker):      func = mocker.Mock(side_effect=KeyError())      Config.core.read_entity_retry = 3        @_retry_read_entity((Exception,))      def decorated_func():          func()        with pytest.raises(KeyError):          decorated_func()      # Called only on the first time and not trigger retry because KeyError is not on the exceptions list      assert func.called == 1 "}
{"text": "from src.taipy.core.common.warn_if_inputs_not_ready import _warn_if_inputs_not_ready  from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from taipy.config import Config      def test_warn_inputs_all_not_ready(caplog):      one = Config.configure_data_node(\"one\")      two = Config.configure_data_node(\"two\")      three = Config.configure_data_node(\"three\")      data_nodes = _DataManagerFactory._build_manager()._bulk_get_or_create({one, two, three}).values()        _warn_if_inputs_not_ready(data_nodes)        stdout = caplog.text      expected_outputs = [          f\"{input_dn.id} cannot be read because it has never been written. Hint: The data node may refer to a wrong \"          f\"path : {input_dn.path} \"          for input_dn in data_nodes      ]      assert all([expected_output in stdout for expected_output in expected_outputs])      def test_warn_inputs_all_ready(caplog):      one = Config.configure_data_node(\"one\", default_data=1)      two = Config.configure_data_node(\"two\", default_data=2)      three = Config.configure_data_node(\"three\", default_data=3)      data_nodes = _DataManagerFactory._build_manager()._bulk_get_or_create({one, two, three}).values()        _warn_if_inputs_not_ready(data_nodes)        stdout = caplog.text      not_expected_outputs = [          f\"{input_dn.id} cannot be read because it has never been written. Hint: The data node may refer to a wrong \"          f\"path : {input_dn.path} \"          for input_dn in data_nodes      ]      assert all([expected_output not in stdout for expected_output in not_expected_outputs])      def test_warn_inputs_one_ready(caplog):      one = Config.configure_data_node(\"one\", default_data=1)      two = Config.configure_data_node(\"two\")      three = Config.configure_data_node(\"three\")      data_nodes = _DataManagerFactory._build_manager()._bulk_get_or_create({one, two, three})        _warn_if_inputs_not_ready(data_nodes.values())        stdout = caplog.text      expected_outputs = [          f\"{input_dn.id} cannot be read because it has never been written. Hint: The data node may refer to a wrong \"          f\"path : {input_dn.path} \"          for input_dn in [data_nodes[two], data_nodes[three]]      ]        not_expected_outputs = [          f\"{input_dn.id} cannot be read because it has never been written. Hint: The data node may refer to a wrong \"          f\"path : {input_dn.path} \"          for input_dn in [data_nodes[one]]      ]        assert all([expected_output in stdout for expected_output in expected_outputs])      assert all([expected_output not in stdout for expected_output in not_expected_outputs])      def test_submit_task_with_input_dn_wrong_file_path(caplog):      csv_dn_cfg = Config.configure_csv_data_node(\"wrong_csv_file_path\", default_path=\"wrong_path.csv\")      excel_dn_cfg = Config.configure_excel_data_node(\"wrong_excel_file_path\", default_path=\"wrong_path.xlsx\")      json_dn_cfg = Config.configure_json_data_node(\"wrong_json_file_path\", default_path=\"wrong_path.json\")      pickle_dn_cfg = Config.configure_pickle_data_node(\"wrong_pickle_file_path\", default_path=\"wrong_path.pickle\")      parquet_dn_cfg = Config.configure_parquet_data_node(\"wrong_parquet_file_path\", default_path=\"wrong_path.parquet\")      input_dn_cfgs = [csv_dn_cfg, excel_dn_cfg, json_dn_cfg, pickle_dn_cfg, parquet_dn_cfg]        dn_manager = _DataManagerFactory._build_manager()      dns = [dn_manager._bulk_get_or_create([input_dn_cfg])[input_dn_cfg] for input_dn_cfg in input_dn_cfgs]        _warn_if_inputs_not_ready(dns)        stdout = caplog.text      expected_outputs = [          f\"{input_dn.id} cannot be read because it has never been written. Hint: The data node may refer to a wrong \"          f\"path : {input_dn.path} \"          for input_dn in dns      ]      assert all([expected_output in stdout for expected_output in expected_outputs]) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import os    import pytest    from src.taipy.core.exceptions import ModelNotFound  from src.taipy.core.scenario._scenario_fs_repository import _ScenarioFSRepository  from src.taipy.core.scenario._scenario_sql_repository import _ScenarioSQLRepository  from src.taipy.core.scenario.scenario import Scenario, ScenarioId      class TestScenarioFSRepository:      @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_save_and_load(self, scenario, repo, init_sql_repo):          repository = repo()          repository._save(scenario)            obj = repository._load(scenario.id)          assert isinstance(obj, Scenario)        @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_exists(self, scenario, repo, init_sql_repo):          repository = repo()          repository._save(scenario)            assert repository._exists(scenario.id)          assert not repository._exists(\"not-existed-scenario\")        @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_load_all(self, scenario, repo, init_sql_repo):          repository = repo()          for i in range(10):              scenario.id = ScenarioId(f\"scenario-{i}\")              repository._save(scenario)          data_nodes = repository._load_all()            assert len(data_nodes) == 10        @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_load_all_with_filters(self, scenario, repo, init_sql_repo):          repository = repo()            for i in range(10):              scenario.id = ScenarioId(f\"scenario-{i}\")              repository._save(scenario)          objs = repository._load_all(filters=[{\"id\": \"scenario-2\"}])            assert len(objs) == 1        @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_delete(self, scenario, repo, init_sql_repo):          repository = repo()          repository._save(scenario)            repository._delete(scenario.id)            with pytest.raises(ModelNotFound):              repository._load(scenario.id)        @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_delete_all(self, scenario, repo, init_sql_repo):          repository = repo()            for i in range(10):              scenario.id = ScenarioId(f\"scenario-{i}\")              repository._save(scenario)            assert len(repository._load_all()) == 10            repository._delete_all()            assert len(repository._load_all()) == 0        @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_delete_many(self, scenario, repo, init_sql_repo):          repository = repo()            for i in range(10):              scenario.id = ScenarioId(f\"scenario-{i}\")              repository._save(scenario)            objs = repository._load_all()          assert len(objs) == 10          ids = [x.id for x in objs[:3]]          repository._delete_many(ids)            assert len(repository._load_all()) == 7        @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_delete_by(self, scenario, repo, init_sql_repo):          repository = repo()            # Create 5 entities with version 1.0 and 5 entities with version 2.0          for i in range(10):              scenario.id = ScenarioId(f\"scenario-{i}\")              scenario._version = f\"{(i+1) // 5}.0\"              repository._save(scenario)            objs = repository._load_all()          assert len(objs) == 10          repository._delete_by(\"version\", \"1.0\")            assert len(repository._load_all()) == 5        @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_search(self, scenario, repo, init_sql_repo):          repository = repo()            for i in range(10):              scenario.id = ScenarioId(f\"scenario-{i}\")              repository._save(scenario)            assert len(repository._load_all()) == 10            objs = repository._search(\"id\", \"scenario-2\")          assert len(objs) == 1          assert isinstance(objs[0], Scenario)            objs = repository._search(\"id\", \"scenario-2\", filters=[{\"version\": \"random_version_number\"}])          assert len(objs) == 1          assert isinstance(objs[0], Scenario)            assert repository._search(\"id\", \"scenario-2\", filters=[{\"version\": \"non_existed_version\"}]) == []        @pytest.mark.parametrize(\"repo\", [_ScenarioFSRepository, _ScenarioSQLRepository])      def test_export(self, tmpdir, scenario, repo, init_sql_repo):          repository = repo()          repository._save(scenario)            repository._export(scenario.id, tmpdir.strpath)          dir_path = repository.dir_path if repo == _ScenarioFSRepository else os.path.join(tmpdir.strpath, \"scenario\")            assert os.path.exists(os.path.join(dir_path, f\"{scenario.id}.json\")) "}
{"text": "from src.taipy.core._version._version import _Version  from taipy.config.config import Config      def test_create_version():      v = _Version(\"foo\", config=Config.configure_data_node(\"dn\"))      assert v.id == \"foo\"      assert v.config is not None "}
{"text": "import os    import pytest    from src.taipy.core._version._version import _Version  from src.taipy.core._version._version_fs_repository import _VersionFSRepository  from src.taipy.core._version._version_sql_repository import _VersionSQLRepository  from src.taipy.core.exceptions import ModelNotFound      class TestVersionFSRepository:      @pytest.mark.parametrize(\"repo\", [_VersionFSRepository, _VersionSQLRepository])      def test_save_and_load(self, _version, repo, init_sql_repo):          repository = repo()          repository._save(_version)            obj = repository._load(_version.id)          assert isinstance(obj, _Version)        @pytest.mark.parametrize(\"repo\", [_VersionFSRepository, _VersionSQLRepository])      def test_exists(self, _version, repo, init_sql_repo):          repository = repo()          repository._save(_version)            assert repository._exists(_version.id)          assert not repository._exists(\"not-existed-version\")        @pytest.mark.parametrize(\"repo\", [_VersionFSRepository, _VersionSQLRepository])      def test_load_all(self, _version, repo, init_sql_repo):          repository = repo()          for i in range(10):              _version.id = f\"_version_{i}\"              repository._save(_version)          data_nodes = repository._load_all()            assert len(data_nodes) == 10        @pytest.mark.parametrize(\"repo\", [_VersionFSRepository, _VersionSQLRepository])      def test_load_all_with_filters(self, _version, repo, init_sql_repo):          repository = repo()            for i in range(10):              _version.id = f\"_version_{i}\"              _version.name = f\"_version_{i}\"              repository._save(_version)          objs = repository._load_all(filters=[{\"id\": \"_version_2\"}])            assert len(objs) == 1        @pytest.mark.parametrize(\"repo\", [_VersionFSRepository, _VersionSQLRepository])      def test_delete(self, _version, repo, init_sql_repo):          repository = repo()          repository._save(_version)            repository._delete(_version.id)            with pytest.raises(ModelNotFound):              repository._load(_version.id)        @pytest.mark.parametrize(\"repo\", [_VersionFSRepository, _VersionSQLRepository])      def test_delete_all(self, _version, repo, init_sql_repo):          repository = repo()            for i in range(10):              _version.id = f\"_version_{i}\"              repository._save(_version)            assert len(repository._load_all()) == 10            repository._delete_all()            assert len(repository._load_all()) == 0        @pytest.mark.parametrize(\"repo\", [_VersionFSRepository, _VersionSQLRepository])      def test_delete_many(self, _version, repo, init_sql_repo):          repository = repo()            for i in range(10):              _version.id = f\"_version_{i}\"              repository._save(_version)            objs = repository._load_all()          assert len(objs) == 10          ids = [x.id for x in objs[:3]]          repository._delete_many(ids)            assert len(repository._load_all()) == 7        @pytest.mark.parametrize(\"repo\", [_VersionFSRepository, _VersionSQLRepository])      def test_search(self, _version, repo, init_sql_repo):          repository = repo()            for i in range(10):              _version.id = f\"_version_{i}\"              _version.name = f\"_version_{i}\"              repository._save(_version)            assert len(repository._load_all()) == 10            objs = repository._search(\"id\", \"_version_2\")          assert len(objs) == 1          assert isinstance(objs[0], _Version)        @pytest.mark.parametrize(\"repo\", [_VersionFSRepository, _VersionSQLRepository])      def test_export(self, tmpdir, _version, repo, init_sql_repo):          repository = repo()          repository._save(_version)            repository._export(_version.id, tmpdir.strpath)          dir_path = repository.dir_path if repo == _VersionFSRepository else os.path.join(tmpdir.strpath, \"version\")            assert os.path.exists(os.path.join(dir_path, f\"{_version.id}.json\")) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import pytest    from src.taipy.core._version._version import _Version  from src.taipy.core._version._version_manager import _VersionManager  from taipy.config.config import Config      def test_save_and_get_version_entity(tmpdir):      _VersionManager._repository.base_path = tmpdir      assert len(_VersionManager._get_all()) == 0        version = _Version(id=\"foo\", config=Config._applied_config)        _VersionManager._get_or_create(id=\"foo\", force=False)        version_1 = _VersionManager._get(version.id)      assert version_1.id == version.id      assert Config._serializer._str(version_1.config) == Config._serializer._str(version.config)        assert len(_VersionManager._get_all()) == 1      assert _VersionManager._get(version.id) == version "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from unittest import mock    import pytest    from src.taipy.core._orchestrator._dispatcher import _DevelopmentJobDispatcher, _JobDispatcher, _StandaloneJobDispatcher  from src.taipy.core._orchestrator._orchestrator import _Orchestrator  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.exceptions.exceptions import OrchestratorNotBuilt  from taipy.config import Config      def test_build_orchestrator():      _OrchestratorFactory._orchestrator = None      _OrchestratorFactory._dispatcher = None        assert _OrchestratorFactory._orchestrator is None      assert _OrchestratorFactory._dispatcher is None        orchestrator = _OrchestratorFactory._build_orchestrator()      assert orchestrator == _Orchestrator      assert _OrchestratorFactory._orchestrator == _Orchestrator      dispatcher = _OrchestratorFactory._build_dispatcher()      assert isinstance(dispatcher, _JobDispatcher)      assert isinstance(_OrchestratorFactory._dispatcher, _JobDispatcher)        _OrchestratorFactory._orchestrator = None      assert _OrchestratorFactory._orchestrator is None      assert _OrchestratorFactory._dispatcher is not None        with mock.patch(          \"src.taipy.core._orchestrator._orchestrator_factory._OrchestratorFactory._build_dispatcher\"      ) as build_dispatcher, mock.patch(          \"src.taipy.core._orchestrator._orchestrator._Orchestrator.initialize\"      ) as initialize:          orchestrator = _OrchestratorFactory._build_orchestrator()          assert orchestrator == _Orchestrator          assert _OrchestratorFactory._orchestrator == _Orchestrator          build_dispatcher.assert_not_called()          initialize.assert_called_once()      def test_build_development_dispatcher():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._orchestrator = None      _OrchestratorFactory._dispatcher = None        assert _OrchestratorFactory._orchestrator is None      assert _OrchestratorFactory._dispatcher is None        with pytest.raises(OrchestratorNotBuilt):          _OrchestratorFactory._build_dispatcher()        _OrchestratorFactory._build_orchestrator()      assert _OrchestratorFactory._orchestrator is not None      assert _OrchestratorFactory._dispatcher is None        _OrchestratorFactory._build_dispatcher()      assert isinstance(_OrchestratorFactory._dispatcher, _DevelopmentJobDispatcher)      def test_build_standalone_dispatcher():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()      assert isinstance(_OrchestratorFactory._dispatcher, _StandaloneJobDispatcher)      assert not isinstance(_OrchestratorFactory._dispatcher, _DevelopmentJobDispatcher)      assert _OrchestratorFactory._dispatcher.is_running()      assert _OrchestratorFactory._dispatcher._nb_available_workers == 2      _OrchestratorFactory._dispatcher._nb_available_workers = 1        _OrchestratorFactory._build_dispatcher(force_restart=False)      assert _OrchestratorFactory._dispatcher.is_running()      assert _OrchestratorFactory._dispatcher._nb_available_workers == 1        _OrchestratorFactory._build_dispatcher(force_restart=True)      assert _OrchestratorFactory._dispatcher.is_running()      assert _OrchestratorFactory._dispatcher._nb_available_workers == 2 "}
{"text": "import multiprocessing  from concurrent.futures import ProcessPoolExecutor  from functools import partial  from unittest import mock  from unittest.mock import MagicMock    from pytest import raises    from src.taipy.core import DataNodeId, JobId, TaskId  from src.taipy.core._orchestrator._dispatcher._development_job_dispatcher import _DevelopmentJobDispatcher  from src.taipy.core._orchestrator._dispatcher._standalone_job_dispatcher import _StandaloneJobDispatcher  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.job.job import Job  from src.taipy.core.submission._submission_manager_factory import _SubmissionManagerFactory  from src.taipy.core.task.task import Task  from taipy.config.config import Config  from tests.core.utils import assert_true_after_time      def execute(lock):      with lock:          ...      return None      def _error():      raise RuntimeError(\"Something bad has happened\")      def test_build_development_job_dispatcher():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()      dispatcher = _OrchestratorFactory._dispatcher        assert isinstance(dispatcher, _DevelopmentJobDispatcher)      assert dispatcher._nb_available_workers == 1        with raises(NotImplementedError):          assert dispatcher.start()        assert dispatcher.is_running()        with raises(NotImplementedError):          dispatcher.stop()      def test_build_standalone_job_dispatcher():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()      dispatcher = _OrchestratorFactory._dispatcher        assert not isinstance(dispatcher, _DevelopmentJobDispatcher)      assert isinstance(dispatcher, _StandaloneJobDispatcher)      assert isinstance(dispatcher._executor, ProcessPoolExecutor)      assert dispatcher._nb_available_workers == 2      assert_true_after_time(dispatcher.is_running)      dispatcher.stop()      dispatcher.join()      assert_true_after_time(lambda: not dispatcher.is_running())      def test_can_execute_2_workers():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        m = multiprocessing.Manager()      lock = m.Lock()        task_id = TaskId(\"task_id1\")      output = list(_DataManager._bulk_get_or_create([Config.configure_data_node(\"input1\", default_data=21)]).values())        _OrchestratorFactory._build_dispatcher()        task = Task(          config_id=\"name\",          properties={},          input=[],          function=partial(execute, lock),          output=output,          id=task_id,      )      job_id = JobId(\"id1\")      job = Job(job_id, task, \"submit_id\", task.id)        dispatcher = _StandaloneJobDispatcher(_OrchestratorFactory._orchestrator)        with lock:          assert dispatcher._can_execute()          dispatcher._dispatch(job)          assert dispatcher._can_execute()          dispatcher._dispatch(job)          assert not dispatcher._can_execute()        assert_true_after_time(lambda: dispatcher._can_execute())      def test_can_execute_synchronous():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        task_id = TaskId(\"task_id1\")      task = Task(config_id=\"name\", properties={}, input=[], function=print, output=[], id=task_id)      submission = _SubmissionManagerFactory._build_manager()._create(task_id, task._ID_PREFIX)      job_id = JobId(\"id1\")      job = Job(job_id, task, submission.id, task.id)        dispatcher = _OrchestratorFactory._dispatcher        assert dispatcher._can_execute()      dispatcher._dispatch(job)      assert dispatcher._can_execute()      def test_exception_in_user_function():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        task_id = TaskId(\"task_id1\")      job_id = JobId(\"id1\")      task = Task(config_id=\"name\", properties={}, input=[], function=_error, output=[], id=task_id)      submission = _SubmissionManagerFactory._build_manager()._create(task_id, task._ID_PREFIX)      job = Job(job_id, task, submission.id, task.id)        dispatcher = _OrchestratorFactory._dispatcher      dispatcher._dispatch(job)      assert job.is_failed()      assert 'RuntimeError(\"Something bad has happened\")' in str(job.stacktrace[0])      def test_exception_in_writing_data():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        task_id = TaskId(\"task_id1\")      job_id = JobId(\"id1\")      output = MagicMock()      output.id = DataNodeId(\"output_id\")      output.config_id = \"my_raising_datanode\"      output._is_in_cache = False      output.write.side_effect = ValueError()      task = Task(config_id=\"name\", properties={}, input=[], function=print, output=[output], id=task_id)      submission = _SubmissionManagerFactory._build_manager()._create(task_id, task._ID_PREFIX)      job = Job(job_id, task, submission.id, task.id)        dispatcher = _OrchestratorFactory._dispatcher        with mock.patch(\"src.taipy.core.data._data_manager._DataManager._get\") as get:          get.return_value = output          dispatcher._dispatch(job)          assert job.is_failed()          assert \"node\" in job.stacktrace[0] "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from src.taipy.core.data import InMemoryDataNode  from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.task._task_model import _TaskModel  from taipy.config.common.scope import Scope      def test_none_properties_attribute_compatible():      model = _TaskModel.from_dict(          {              \"id\": \"id\",              \"config_id\": \"config_id\",              \"parent_id\": \"owner_id\",              \"parent_ids\": [\"parent_id\"],              \"input_ids\": [\"input_id\"],              \"function_name\": \"function_name\",              \"function_module\": \"function_module\",              \"output_ids\": [\"output_id\"],              \"version\": \"latest\",              \"skippable\": False,          }      )      assert len(model.properties) == 0      def test_skippable_compatibility_with_non_existing_output():      model = _TaskModel.from_dict(          {              \"id\": \"id\",              \"config_id\": \"config_id\",              \"owner_id\": \"owner_id\",              \"parent_ids\": [\"parent_id\"],              \"input_ids\": [\"input_id\"],              \"function_name\": \"function_name\",              \"function_module\": \"function_module\",              \"output_ids\": [\"output_id\"],              \"version\": \"latest\",              \"skippable\": False,          }      )      assert not model.skippable      def test_skippable_compatibility_with_no_output():      model = _TaskModel.from_dict(          {              \"id\": \"id\",              \"config_id\": \"config_id\",              \"owner_id\": \"owner_id\",              \"parent_ids\": [\"parent_id\"],              \"input_ids\": [\"input_id\"],              \"function_name\": \"function_name\",              \"function_module\": \"function_module\",              \"output_ids\": [],              \"version\": \"latest\",              \"skippable\": False,          }      )      assert not model.skippable      def test_skippable_compatibility_with_one_output():      manager = _DataManagerFactory._build_manager()      manager._set(InMemoryDataNode(\"cfg_id\", Scope.SCENARIO, id=\"dn_id\"))        model = _TaskModel.from_dict(          {              \"id\": \"id\",              \"config_id\": \"config_id\",              \"owner_id\": \"owner_id\",              \"parent_ids\": [\"parent_id\"],              \"input_ids\": [\"input_id\"],              \"function_name\": \"function_name\",              \"function_module\": \"function_module\",              \"output_ids\": [\"dn_id\"],              \"version\": \"latest\",              \"skippable\": True,          }      )      assert model.skippable      def test_skippable_compatibility_with_many_outputs():      manager = _DataManagerFactory._build_manager()      manager._set(InMemoryDataNode(\"cfg_id\", Scope.SCENARIO, id=\"dn_id\"))      manager._set(InMemoryDataNode(\"cfg_id_2\", Scope.SCENARIO, id=\"dn_2_id\"))      model = _TaskModel.from_dict(          {              \"id\": \"id\",              \"config_id\": \"config_id\",              \"owner_id\": \"owner_id\",              \"parent_ids\": [\"parent_id\"],              \"input_ids\": [\"input_id\"],              \"function_name\": \"function_name\",              \"function_module\": \"function_module\",              \"output_ids\": [\"dn_id\", \"dn_2_id\"],              \"version\": \"latest\",              \"skippable\": True,          }      )      assert model.skippable "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from src.taipy.core.sequence._sequence_converter import _SequenceConverter  from src.taipy.core.sequence.sequence import Sequence  from src.taipy.core.task.task import Task      def test_entity_to_model(sequence):      sequence_model_1 = _SequenceConverter._entity_to_model(sequence)      expected_sequence_model_1 = {          \"id\": \"sequence_id\",          \"owner_id\": \"owner_id\",          \"parent_ids\": [\"parent_id_1\", \"parent_id_2\"],          \"properties\": {},          \"tasks\": [],          \"subscribers\": [],          \"version\": \"random_version_number\",      }      sequence_model_1[\"parent_ids\"] = sorted(sequence_model_1[\"parent_ids\"])      assert sequence_model_1 == expected_sequence_model_1        task_1 = Task(\"task_1\", {}, print)      task_2 = Task(\"task_2\", {}, print)      sequence_2 = Sequence(          {\"name\": \"sequence_2\"},          [task_1, task_2],          \"SEQUENCE_sq_1_SCENARIO_sc\",          \"SCENARIO_sc\",          [\"SCENARIO_sc\"],          [],          \"random_version\",      )      sequence_model_2 = _SequenceConverter._entity_to_model(sequence_2)      expected_sequence_model_2 = {          \"id\": \"SEQUENCE_sq_1_SCENARIO_sc\",          \"owner_id\": \"SCENARIO_sc\",          \"parent_ids\": [\"SCENARIO_sc\"],          \"properties\": {\"name\": \"sequence_2\"},          \"tasks\": [task_1.id, task_2.id],          \"subscribers\": [],          \"version\": \"random_version\",      }      assert sequence_model_2 == expected_sequence_model_2 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from src.taipy.core.data.data_node import DataNode  from src.taipy.core.data.in_memory import InMemoryDataNode  from taipy.config.common.scope import Scope      class FakeDataNode(InMemoryDataNode):      read_has_been_called = 0      write_has_been_called = 0        def __init__(self, config_id, **kwargs):          scope = kwargs.pop(\"scope\", Scope.SCENARIO)          super().__init__(config_id=config_id, scope=scope, **kwargs)        def _read(self, query=None):          self.read_has_been_called += 1        def _write(self, data):          self.write_has_been_called += 1        @classmethod      def storage_type(cls) -> str:          return \"fake_inmemory\"        write = DataNode.write  # Make sure that the writing behavior comes from DataNode      class FakeDataframeDataNode(DataNode):      COLUMN_NAME_1 = \"a\"      COLUMN_NAME_2 = \"b\"        def __init__(self, config_id, default_data_frame, **kwargs):          super().__init__(config_id, **kwargs)          self.data = default_data_frame        def _read(self):          return self.data        @classmethod      def storage_type(cls) -> str:          return \"fake_df_dn\"      class FakeNumpyarrayDataNode(DataNode):      def __init__(self, config_id, default_array, **kwargs):          super().__init__(config_id, **kwargs)          self.data = default_array        def _read(self):          return self.data        @classmethod      def storage_type(cls) -> str:          return \"fake_np_dn\"      class FakeListDataNode(DataNode):      class Row:          def __init__(self, value):              self.value = value        def __init__(self, config_id, **kwargs):          super().__init__(config_id, **kwargs)          self.data = [self.Row(i) for i in range(10)]        def _read(self):          return self.data        @classmethod      def storage_type(cls) -> str:          return \"fake_list_dn\"      class CustomClass:      def __init__(self, a, b):          self.a = a          self.b = b      class FakeCustomDataNode(DataNode):      def __init__(self, config_id, **kwargs):          super().__init__(config_id, **kwargs)          self.data = [CustomClass(i, i * 2) for i in range(10)]        def _read(self):          return self.data      class FakeMultiSheetExcelDataFrameDataNode(DataNode):      def __init__(self, config_id, default_data_frame, **kwargs):          super().__init__(config_id, **kwargs)          self.data = {              \"Sheet1\": default_data_frame,              \"Sheet2\": default_data_frame,          }        def _read(self):          return self.data      class FakeMultiSheetExcelCustomDataNode(DataNode):      def __init__(self, config_id, **kwargs):          super().__init__(config_id, **kwargs)          self.data = {              \"Sheet1\": [CustomClass(i, i * 2) for i in range(10)],              \"Sheet2\": [CustomClass(i, i * 2) for i in range(10)],          }        def _read(self):          return self.data "}
{"text": "import os    import pytest    from src.taipy.core.data._data_fs_repository import _DataFSRepository  from src.taipy.core.data._data_sql_repository import _DataSQLRepository  from src.taipy.core.data.data_node import DataNode, DataNodeId  from src.taipy.core.exceptions import ModelNotFound      class TestDataNodeRepository:      @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_save_and_load(self, data_node, repo, init_sql_repo):          repository = repo()          repository._save(data_node)            obj = repository._load(data_node.id)          assert isinstance(obj, DataNode)        @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_exists(self, data_node, repo, init_sql_repo):          repository = repo()          repository._save(data_node)            assert repository._exists(data_node.id)          assert not repository._exists(\"not-existed-data-node\")        @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_load_all(self, data_node, repo, init_sql_repo):          repository = repo()          for i in range(10):              data_node.id = DataNodeId(f\"data_node-{i}\")              repository._save(data_node)          data_nodes = repository._load_all()            assert len(data_nodes) == 10        @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_load_all_with_filters(self, data_node, repo, init_sql_repo):          repository = repo()            for i in range(10):              data_node.id = DataNodeId(f\"data_node-{i}\")              data_node.owner_id = f\"task-{i}\"              repository._save(data_node)          objs = repository._load_all(filters=[{\"owner_id\": \"task-2\"}])            assert len(objs) == 1        @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_delete(self, data_node, repo, init_sql_repo):          repository = repo()          repository._save(data_node)            repository._delete(data_node.id)            with pytest.raises(ModelNotFound):              repository._load(data_node.id)        @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_delete_all(self, data_node, repo, init_sql_repo):          repository = repo()            for i in range(10):              data_node.id = DataNodeId(f\"data_node-{i}\")              repository._save(data_node)            assert len(repository._load_all()) == 10            repository._delete_all()            assert len(repository._load_all()) == 0        @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_delete_many(self, data_node, repo, init_sql_repo):          repository = repo()            for i in range(10):              data_node.id = DataNodeId(f\"data_node-{i}\")              repository._save(data_node)            objs = repository._load_all()          assert len(objs) == 10          ids = [x.id for x in objs[:3]]          repository._delete_many(ids)            assert len(repository._load_all()) == 7        @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_delete_by(self, data_node, repo, init_sql_repo):          repository = repo()            # Create 5 entities with version 1.0 and 5 entities with version 2.0          for i in range(10):              data_node.id = DataNodeId(f\"data_node-{i}\")              data_node._version = f\"{(i+1) // 5}.0\"              repository._save(data_node)            objs = repository._load_all()          assert len(objs) == 10          repository._delete_by(\"version\", \"1.0\")            assert len(repository._load_all()) == 5        @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_search(self, data_node, repo, init_sql_repo):          repository = repo()            for i in range(10):              data_node.id = DataNodeId(f\"data_node-{i}\")              data_node.owner_id = f\"task-{i}\"              repository._save(data_node)            assert len(repository._load_all()) == 10            objs = repository._search(\"owner_id\", \"task-2\")          assert len(objs) == 1          assert isinstance(objs[0], DataNode)            objs = repository._search(\"owner_id\", \"task-2\", filters=[{\"version\": \"random_version_number\"}])          assert len(objs) == 1          assert isinstance(objs[0], DataNode)            assert repository._search(\"owner_id\", \"task-2\", filters=[{\"version\": \"non_existed_version\"}]) == []        @pytest.mark.parametrize(\"repo\", [_DataFSRepository, _DataSQLRepository])      def test_export(self, tmpdir, data_node, repo, init_sql_repo):          repository = repo()          repository._save(data_node)            repository._export(data_node.id, tmpdir.strpath)          dir_path = repository.dir_path if repo == _DataFSRepository else os.path.join(tmpdir.strpath, \"data_node\")            assert os.path.exists(os.path.join(dir_path, f\"{data_node.id}.json\")) "}
{"text": "import pytest    from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.exceptions.exceptions import NoData  from taipy.config.common.scope import Scope  from taipy.config.exceptions.exceptions import InvalidConfigurationId      class TestInMemoryDataNodeEntity:      def test_create(self):          dn = InMemoryDataNode(              \"foobar_bazy\",              Scope.SCENARIO,              DataNodeId(\"id_uio\"),              \"owner_id\",              properties={\"default_data\": \"In memory Data Node\", \"name\": \"my name\"},          )          assert isinstance(dn, InMemoryDataNode)          assert dn.storage_type() == \"in_memory\"          assert dn.config_id == \"foobar_bazy\"          assert dn.scope == Scope.SCENARIO          assert dn.id == \"id_uio\"          assert dn.name == \"my name\"          assert dn.owner_id == \"owner_id\"          assert dn.last_edit_date is not None          assert dn.job_ids == []          assert dn.is_ready_for_reading          assert dn.read() == \"In memory Data Node\"            dn_2 = InMemoryDataNode(\"foo\", Scope.SCENARIO)          assert dn_2.last_edit_date is None          assert not dn_2.is_ready_for_reading            with pytest.raises(InvalidConfigurationId):              InMemoryDataNode(\"foo bar\", Scope.SCENARIO, DataNodeId(\"dn_id\"))        def test_get_user_properties(self):          dn = InMemoryDataNode(\"foo\", Scope.SCENARIO, properties={\"default_data\": 1, \"foo\": \"bar\"})          assert dn._get_user_properties() == {\"foo\": \"bar\"}        def test_read_and_write(self):          no_data_dn = InMemoryDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"))          with pytest.raises(NoData):              assert no_data_dn.read() is None              no_data_dn.read_or_raise()          in_mem_dn = InMemoryDataNode(\"foo\", Scope.SCENARIO, properties={\"default_data\": \"bar\"})          assert isinstance(in_mem_dn.read(), str)          assert in_mem_dn.read() == \"bar\"          in_mem_dn.properties[\"default_data\"] = \"baz\"  # this modifies the default data value but not the data itself          assert in_mem_dn.read() == \"bar\"          in_mem_dn.write(\"qux\")          assert in_mem_dn.read() == \"qux\"          in_mem_dn.write(1998)          assert isinstance(in_mem_dn.read(), int)          assert in_mem_dn.read() == 1998 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from datetime import datetime  from time import sleep    from src.taipy.core._version._version_manager_factory import _VersionManagerFactory  from src.taipy.core.submission._submission_manager_factory import _SubmissionManagerFactory  from src.taipy.core.submission.submission import Submission  from src.taipy.core.submission.submission_status import SubmissionStatus  from src.taipy.core.task.task import Task      def test_create_submission(scenario):      submission_1 = _SubmissionManagerFactory._build_manager()._create(scenario.id, scenario._ID_PREFIX)        assert submission_1.id is not None      assert submission_1.entity_id == scenario.id      assert submission_1.jobs == []      assert isinstance(submission_1.creation_date, datetime)      assert submission_1._submission_status == SubmissionStatus.SUBMITTED      def test_get_submission():      submission_manager = _SubmissionManagerFactory._build_manager()        assert submission_manager._get(\"random_submission_id\") is None        submission_1 = submission_manager._create(\"entity_id\", \"ENTITY_TYPE\")      submission_2 = submission_manager._get(submission_1.id)        assert submission_1.id == submission_2.id      assert submission_1.entity_id == submission_2.entity_id == \"entity_id\"      assert submission_1.jobs == submission_2.jobs      assert submission_1.creation_date == submission_2.creation_date      assert submission_1.submission_status == submission_2.submission_status      def test_get_all_submission():      submission_manager = _SubmissionManagerFactory._build_manager()      version_manager = _VersionManagerFactory._build_manager()        submission_manager._set(Submission(\"entity_id\", \"submission_id\", version=version_manager._get_latest_version()))      for version_name in [\"abc\", \"xyz\"]:          for i in range(10):              submission_manager._set(                  Submission(\"entity_id\", f\"submission_{version_name}_{i}\", version=f\"{version_name}\")              )        assert len(submission_manager._get_all()) == 1        version_manager._set_experiment_version(\"xyz\")      version_manager._set_experiment_version(\"abc\")      assert len(submission_manager._get_all()) == 10      assert len(submission_manager._get_all(\"abc\")) == 10      assert len(submission_manager._get_all(\"xyz\")) == 10      def test_get_latest_submission():      task_1 = Task(\"task_config_1\", {}, print, id=\"task_id_1\")      task_2 = Task(\"task_config_2\", {}, print, id=\"task_id_2\")        submission_manager = _SubmissionManagerFactory._build_manager()      submission_1 = submission_manager._create(task_1.id, task_1._ID_PREFIX)      assert submission_manager._get_latest(task_1) == submission_1      assert submission_manager._get_latest(task_2) is None        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      submission_2 = submission_manager._create(task_2.id, task_2._ID_PREFIX)      assert submission_manager._get_latest(task_1) == submission_1      assert submission_manager._get_latest(task_2) == submission_2        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      submission_3 = submission_manager._create(task_1.id, task_1._ID_PREFIX)      assert submission_manager._get_latest(task_1) == submission_3      assert submission_manager._get_latest(task_2) == submission_2        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      submission_4 = submission_manager._create(task_2.id, task_2._ID_PREFIX)      assert submission_manager._get_latest(task_1) == submission_3      assert submission_manager._get_latest(task_2) == submission_4      def test_delete_submission():      submission_manager = _SubmissionManagerFactory._build_manager()        submission = Submission(\"entity_id\", \"submission_id\")      submission_manager._set(submission)        for i in range(10):          submission_manager._set(Submission(\"entity_id\", f\"submission_{i}\"))        assert len(submission_manager._get_all()) == 11      assert isinstance(submission_manager._get(submission.id), Submission)        submission_manager._delete(submission.id)      assert len(submission_manager._get_all()) == 10      assert submission_manager._get(submission.id) is None        submission_manager._delete_all()      assert len(submission_manager._get_all()) == 0 "}
{"text": "from datetime import datetime  from time import sleep    from src.taipy.core import Task  from src.taipy.core._repository.db._sql_connection import _SQLConnection  from src.taipy.core._version._version_manager_factory import _VersionManagerFactory  from src.taipy.core.submission._submission_manager_factory import _SubmissionManagerFactory  from src.taipy.core.submission.submission import Submission  from src.taipy.core.submission.submission_status import SubmissionStatus      def init_managers():      _VersionManagerFactory._build_manager()._delete_all()      _SubmissionManagerFactory._build_manager()._delete_all()      def test_create_submission(scenario, init_sql_repo):      init_managers()        submission_1 = _SubmissionManagerFactory._build_manager()._create(scenario.id, scenario._ID_PREFIX)        assert submission_1.id is not None      assert submission_1.entity_id == scenario.id      assert submission_1.jobs == []      assert isinstance(submission_1.creation_date, datetime)      assert submission_1._submission_status == SubmissionStatus.SUBMITTED      def test_get_submission(init_sql_repo):      init_managers()        submission_manager = _SubmissionManagerFactory._build_manager()        submission_1 = submission_manager._create(\"entity_id\", \"ENTITY_TYPE\")      submission_2 = submission_manager._get(submission_1.id)        assert submission_1.id == submission_2.id      assert submission_1.entity_id == submission_2.entity_id == \"entity_id\"      assert submission_1.jobs == submission_2.jobs      assert submission_1.creation_date == submission_2.creation_date      assert submission_1.submission_status == submission_2.submission_status      def test_get_all_submission(init_sql_repo):      init_managers()        submission_manager = _SubmissionManagerFactory._build_manager()      version_manager = _VersionManagerFactory._build_manager()        submission_manager._set(Submission(\"entity_id\", \"submission_id\", version=version_manager._get_latest_version()))      for version_name in [\"abc\", \"xyz\"]:          for i in range(10):              submission_manager._set(                  Submission(\"entity_id\", f\"submission_{version_name}_{i}\", version=f\"{version_name}\")              )      assert len(submission_manager._get_all()) == 1        version_manager._set_experiment_version(\"xyz\")      version_manager._set_experiment_version(\"abc\")      assert len(submission_manager._get_all()) == 10      assert len(submission_manager._get_all(\"abc\")) == 10      assert len(submission_manager._get_all(\"xyz\")) == 10      def test_get_latest_submission(init_sql_repo):      init_managers()        task_1 = Task(\"task_config_1\", {}, print, id=\"task_id_1\")      task_2 = Task(\"task_config_2\", {}, print, id=\"task_id_2\")        submission_manager = _SubmissionManagerFactory._build_manager()      submission_1 = submission_manager._create(task_1.id, task_1._ID_PREFIX)      assert submission_manager._get_latest(task_1) == submission_1      assert submission_manager._get_latest(task_2) is None        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      submission_2 = submission_manager._create(task_2.id, task_2._ID_PREFIX)      assert submission_manager._get_latest(task_1) == submission_1      assert submission_manager._get_latest(task_2) == submission_2        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      submission_3 = submission_manager._create(task_1.id, task_1._ID_PREFIX)      assert submission_manager._get_latest(task_1) == submission_3      assert submission_manager._get_latest(task_2) == submission_2        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      submission_4 = submission_manager._create(task_2.id, task_2._ID_PREFIX)      assert submission_manager._get_latest(task_1) == submission_3      assert submission_manager._get_latest(task_2) == submission_4      def test_delete_submission(init_sql_repo):      init_managers()        submission_manager = _SubmissionManagerFactory._build_manager()        submission = Submission(\"entity_id\", \"submission_id\")      submission_manager._set(submission)        for i in range(10):          submission_manager._set(Submission(\"entity_id\", f\"submission_{i}\"))        assert len(submission_manager._get_all()) == 11      assert isinstance(submission_manager._get(submission.id), Submission)        submission_manager._delete(submission.id)      assert len(submission_manager._get_all()) == 10      assert submission_manager._get(submission.id) is None        submission_manager._delete_all()      assert len(submission_manager._get_all()) == 0 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import os  import pathlib  from unittest import TestCase, mock    from src.taipy.logger._taipy_logger import _TaipyLogger      class TestTaipyLogger(TestCase):      def test_taipy_logger(self):          _TaipyLogger._get_logger().info(\"baz\")          _TaipyLogger._get_logger().debug(\"qux\")        def test_taipy_logger_configured_by_file(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"logger.conf\")          with mock.patch.dict(os.environ, {\"TAIPY_LOGGER_CONFIG_PATH\": path}):              _TaipyLogger._get_logger().info(\"baz\")              _TaipyLogger._get_logger().debug(\"qux\") "}
{"text": "import os    import pytest    from src.taipy.config.config import Config  from src.taipy.config.exceptions.exceptions import ConfigurationUpdateBlocked  from tests.config.utils.named_temporary_file import NamedTemporaryFile    config_from_filename = NamedTemporaryFile(      \"\"\"  [TAIPY]  custom_property_not_overwritten = true  custom_property_overwritten = 10  \"\"\"  )    config_from_environment = NamedTemporaryFile(      \"\"\"  [TAIPY]  custom_property_overwritten = 11  \"\"\"  )      def test_load_from_environment_overwrite_load_from_filename():      os.environ[Config._ENVIRONMENT_VARIABLE_NAME_WITH_CONFIG_PATH] = config_from_environment.filename      Config.load(config_from_filename.filename)        assert Config.global_config.custom_property_not_overwritten is True      assert Config.global_config.custom_property_overwritten == 11      os.environ.pop(Config._ENVIRONMENT_VARIABLE_NAME_WITH_CONFIG_PATH)      def test_block_load_from_environment_overwrite_load_from_filename():      Config.load(config_from_filename.filename)      assert Config.global_config.custom_property_not_overwritten is True      assert Config.global_config.custom_property_overwritten == 10        Config.block_update()        with pytest.raises(ConfigurationUpdateBlocked):          os.environ[Config._ENVIRONMENT_VARIABLE_NAME_WITH_CONFIG_PATH] = config_from_environment.filename          Config.load(config_from_filename.filename)        os.environ.pop(Config._ENVIRONMENT_VARIABLE_NAME_WITH_CONFIG_PATH)      assert Config.global_config.custom_property_not_overwritten is True      assert Config.global_config.custom_property_overwritten == 10  # The Config.load is failed to override "}
{"text": "import pytest    from src.taipy.config._config import _Config  from src.taipy.config._config_comparator._config_comparator import _ConfigComparator  from src.taipy.config._serializer._toml_serializer import _TomlSerializer  from src.taipy.config.checker.issue_collector import IssueCollector  from src.taipy.config.config import Config  from src.taipy.config.section import Section  from tests.config.utils.section_for_tests import SectionForTest  from tests.config.utils.unique_section_for_tests import UniqueSectionForTest      @pytest.fixture(scope=\"function\", autouse=True)  def reset():      reset_configuration_singleton()      register_test_sections()      def reset_configuration_singleton():      Config.unblock_update()      Config._default_config = _Config()._default_config()      Config._python_config = _Config()      Config._file_config = _Config()      Config._env_file_config = _Config()      Config._applied_config = _Config()      Config._collector = IssueCollector()      Config._serializer = _TomlSerializer()      Config._comparator = _ConfigComparator()      def register_test_sections():      Config._register_default(UniqueSectionForTest(\"default_attribute\"))      Config.configure_unique_section_for_tests = UniqueSectionForTest._configure      Config.unique_section_name = Config.unique_sections[UniqueSectionForTest.name]        Config._register_default(SectionForTest(Section._DEFAULT_KEY, \"default_attribute\", prop=\"default_prop\", prop_int=0))      Config.configure_section_for_tests = SectionForTest._configure      Config.section_name = Config.sections[SectionForTest.name] "}
{"text": "import os  from unittest import mock    import pytest    from src.taipy.config.exceptions.exceptions import InvalidConfigurationId  from tests.config.utils.section_for_tests import SectionForTest  from tests.config.utils.unique_section_for_tests import UniqueSectionForTest      class WrongUniqueSection(UniqueSectionForTest):      name = \"1wrong_id\"      class WrongSection(SectionForTest):      name = \"correct_name\"      def test_section_uses_valid_id():      with pytest.raises(InvalidConfigurationId):          WrongUniqueSection(attribute=\"foo\")      with pytest.raises(InvalidConfigurationId):          WrongSection(\"wrong id\", attribute=\"foo\")      with pytest.raises(InvalidConfigurationId):          WrongSection(\"1wrong_id\", attribute=\"foo\")      with pytest.raises(InvalidConfigurationId):          WrongSection(\"wrong_@id\", attribute=\"foo\")      def test_templated_properties_are_replaced():      with mock.patch.dict(os.environ, {\"foo\": \"bar\", \"baz\": \"1\"}):          u_sect = UniqueSectionForTest(attribute=\"attribute\", tpl_property=\"ENV[foo]\")          assert u_sect.tpl_property == \"bar\"            sect = SectionForTest(id=\"my_id\", attribute=\"attribute\", tpl_property=\"ENV[baz]:int\")          assert sect.tpl_property == 1 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from src.taipy.config.config import Config  from src.taipy.config.global_app.global_app_config import GlobalAppConfig  from src.taipy.config.section import Section  from tests.config.utils.section_for_tests import SectionForTest  from tests.config.utils.unique_section_for_tests import UniqueSectionForTest      def _test_default_global_app_config(global_config: GlobalAppConfig):      assert global_config is not None      assert not global_config.notification      assert len(global_config.properties) == 0      def test_default_configuration():      default_config = Config._default_config      assert default_config._unique_sections is not None      assert len(default_config._unique_sections) == 1      assert default_config._unique_sections[UniqueSectionForTest.name] is not None      assert default_config._unique_sections[UniqueSectionForTest.name].attribute == \"default_attribute\"      assert default_config._sections is not None      assert len(default_config._sections) == 1        _test_default_global_app_config(default_config._global_config)      _test_default_global_app_config(Config.global_config)      _test_default_global_app_config(GlobalAppConfig().default_config())      def test_register_default_configuration():      Config._register_default(SectionForTest(Section._DEFAULT_KEY, \"default_attribute\", prop1=\"prop1\"))        # Replace the first default section      Config._register_default(SectionForTest(Section._DEFAULT_KEY, \"default_attribute\", prop2=\"prop2\"))        default_section = Config.sections[SectionForTest.name][Section._DEFAULT_KEY]      assert len(default_section.properties) == 1      assert default_section.prop2 == \"prop2\"      assert default_section.prop1 is None "}
{"text": "import pytest    from src.taipy.config.config import Config  from src.taipy.config.exceptions.exceptions import LoadingError  from tests.config.utils.named_temporary_file import NamedTemporaryFile      def test_node_can_not_appear_twice():      config = NamedTemporaryFile(          \"\"\"  [unique_section_name]  attribute = \"my_attribute\"    [unique_section_name]  attribute = \"other_attribute\"      \"\"\"      )        with pytest.raises(LoadingError, match=\"Can not load configuration\"):          Config.load(config.filename)      def test_skip_configuration_outside_nodes():      config = NamedTemporaryFile(          \"\"\"  foo = \"bar\"      \"\"\"      )        Config.load(config.filename)      assert Config.global_config.foo is None "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from src.taipy.config._config import _Config  from src.taipy.config.checker._checker import _Checker      class TestDefaultConfigChecker:      def test_check_default_config(self):          config = _Config._default_config()          collector = _Checker._check(config)          assert len(collector._errors) == 0          assert len(collector._infos) == 0          assert len(collector._warnings) == 0 "}
{"text": "from src.taipy.config.checker.issue import Issue  from src.taipy.config.checker.issue_collector import IssueCollector      class TestIssueCollector:      def test_add_error(self):          collector = IssueCollector()          assert len(collector.errors) == 0          assert len(collector.warnings) == 0          assert len(collector.infos) == 0          assert len(collector.all) == 0          collector._add_error(\"field\", \"value\", \"message\", \"checker\")          assert len(collector.errors) == 1          assert len(collector.warnings) == 0          assert len(collector.infos) == 0          assert len(collector.all) == 1          assert collector.all[0] == Issue(IssueCollector._ERROR_LEVEL, \"field\", \"value\", \"message\", \"checker\")          collector._add_error(\"field\", \"value\", \"message\", \"checker\")          assert len(collector.errors) == 2          assert len(collector.warnings) == 0          assert len(collector.infos) == 0          assert len(collector.all) == 2          assert collector.all[0] == Issue(IssueCollector._ERROR_LEVEL, \"field\", \"value\", \"message\", \"checker\")          assert collector.all[1] == Issue(IssueCollector._ERROR_LEVEL, \"field\", \"value\", \"message\", \"checker\")        def test_add_warning(self):          collector = IssueCollector()          assert len(collector.errors) == 0          assert len(collector.warnings) == 0          assert len(collector.infos) == 0          assert len(collector.all) == 0          collector._add_warning(\"field\", \"value\", \"message\", \"checker\")          assert len(collector.errors) == 0          assert len(collector.warnings) == 1          assert len(collector.infos) == 0          assert len(collector.all) == 1          assert collector.all[0] == Issue(IssueCollector._WARNING_LEVEL, \"field\", \"value\", \"message\", \"checker\")          collector._add_warning(\"field\", \"value\", \"message\", \"checker\")          assert len(collector.errors) == 0          assert len(collector.warnings) == 2          assert len(collector.infos) == 0          assert len(collector.all) == 2          assert collector.all[0] == Issue(IssueCollector._WARNING_LEVEL, \"field\", \"value\", \"message\", \"checker\")          assert collector.all[1] == Issue(IssueCollector._WARNING_LEVEL, \"field\", \"value\", \"message\", \"checker\")        def test_add_info(self):          collector = IssueCollector()          assert len(collector.errors) == 0          assert len(collector.warnings) == 0          assert len(collector.infos) == 0          assert len(collector.all) == 0          collector._add_info(\"field\", \"value\", \"message\", \"checker\")          assert len(collector.errors) == 0          assert len(collector.warnings) == 0          assert len(collector.infos) == 1          assert len(collector.all) == 1          assert collector.all[0] == Issue(IssueCollector._INFO_LEVEL, \"field\", \"value\", \"message\", \"checker\")          collector._add_info(\"field\", \"value\", \"message\", \"checker\")          assert len(collector.errors) == 0          assert len(collector.warnings) == 0          assert len(collector.infos) == 2          assert len(collector.all) == 2          assert collector.all[0] == Issue(IssueCollector._INFO_LEVEL, \"field\", \"value\", \"message\", \"checker\")          assert collector.all[1] == Issue(IssueCollector._INFO_LEVEL, \"field\", \"value\", \"message\", \"checker\")        def test_all(self):          collector = IssueCollector()          collector._add_info(\"foo\", \"bar\", \"baz\", \"qux\")          assert collector.all[0] == Issue(IssueCollector._INFO_LEVEL, \"foo\", \"bar\", \"baz\", \"qux\")          collector._add_warning(\"foo2\", \"bar2\", \"baz2\", \"qux2\")          assert collector.all[0] == Issue(IssueCollector._WARNING_LEVEL, \"foo2\", \"bar2\", \"baz2\", \"qux2\")          assert collector.all[1] == Issue(IssueCollector._INFO_LEVEL, \"foo\", \"bar\", \"baz\", \"qux\")          collector._add_warning(\"foo3\", \"bar3\", \"baz3\", \"qux3\")          assert collector.all[0] == Issue(IssueCollector._WARNING_LEVEL, \"foo2\", \"bar2\", \"baz2\", \"qux2\")          assert collector.all[1] == Issue(IssueCollector._WARNING_LEVEL, \"foo3\", \"bar3\", \"baz3\", \"qux3\")          assert collector.all[2] == Issue(IssueCollector._INFO_LEVEL, \"foo\", \"bar\", \"baz\", \"qux\")          collector._add_info(\"field\", \"value\", \"message\", \"checker\")          collector._add_error(\"field\", \"value\", \"message\", \"checker\")          assert collector.all[0] == Issue(IssueCollector._ERROR_LEVEL, \"field\", \"value\", \"message\", \"checker\")          assert collector.all[1] == Issue(IssueCollector._WARNING_LEVEL, \"foo2\", \"bar2\", \"baz2\", \"qux2\")          assert collector.all[2] == Issue(IssueCollector._WARNING_LEVEL, \"foo3\", \"bar3\", \"baz3\", \"qux3\")          assert collector.all[3] == Issue(IssueCollector._INFO_LEVEL, \"foo\", \"bar\", \"baz\", \"qux\")          assert collector.all[4] == Issue(IssueCollector._INFO_LEVEL, \"field\", \"value\", \"message\", \"checker\") "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import os  from unittest import mock  from unittest.mock import MagicMock    from src.taipy.config import Config  from src.taipy.config.checker._checker import _Checker  from src.taipy.config.checker.issue_collector import IssueCollector  from tests.config.utils.checker_for_tests import CheckerForTest      def test_register_checker():      checker = CheckerForTest      checker._check = MagicMock()      _Checker.add_checker(checker)      Config.check()      checker._check.assert_called_once() "}
{"text": "import logging  from unittest import mock    from src.taipy.config._config import _Config  from src.taipy.config.checker._checkers._config_checker import _ConfigChecker  from src.taipy.config.checker.issue import Issue  from src.taipy.config.checker.issue_collector import IssueCollector      class MyCustomChecker(_ConfigChecker):      def _check(self) -> IssueCollector:  # type: ignore          pass      def test__error():      with mock.patch.object(logging.Logger, \"error\"):          collector = IssueCollector()          assert len(collector.all) == 0          _ConfigChecker(_Config(), collector)._error(\"field\", 17, \"my message\")          assert len(collector.all) == 1          assert len(collector.errors) == 1          assert len(collector.warnings) == 0          assert len(collector.infos) == 0          assert collector.errors[0] == Issue(IssueCollector._ERROR_LEVEL, \"field\", 17, \"my message\", \"_ConfigChecker\")            MyCustomChecker(_Config(), collector)._error(\"foo\", \"bar\", \"baz\")          assert len(collector.all) == 2          assert len(collector.errors) == 2          assert len(collector.warnings) == 0          assert len(collector.infos) == 0          assert collector.errors[0] == Issue(IssueCollector._ERROR_LEVEL, \"field\", 17, \"my message\", \"_ConfigChecker\")          assert collector.errors[1] == Issue(IssueCollector._ERROR_LEVEL, \"foo\", \"bar\", \"baz\", \"MyCustomChecker\")      def test__warning():      collector = IssueCollector()      assert len(collector.all) == 0      _ConfigChecker(_Config(), collector)._warning(\"field\", 17, \"my message\")      assert len(collector.all) == 1      assert len(collector.warnings) == 1      assert len(collector.errors) == 0      assert len(collector.infos) == 0      assert collector.warnings[0] == Issue(IssueCollector._WARNING_LEVEL, \"field\", 17, \"my message\", \"_ConfigChecker\")        MyCustomChecker(_Config(), collector)._warning(\"foo\", \"bar\", \"baz\")      assert len(collector.all) == 2      assert len(collector.warnings) == 2      assert len(collector.errors) == 0      assert len(collector.infos) == 0      assert collector.warnings[0] == Issue(IssueCollector._WARNING_LEVEL, \"field\", 17, \"my message\", \"_ConfigChecker\")      assert collector.warnings[1] == Issue(IssueCollector._WARNING_LEVEL, \"foo\", \"bar\", \"baz\", \"MyCustomChecker\")      def test__info():      collector = IssueCollector()      assert len(collector.all) == 0      _ConfigChecker(_Config(), collector)._info(\"field\", 17, \"my message\")      assert len(collector.all) == 1      assert len(collector.infos) == 1      assert len(collector.errors) == 0      assert len(collector.warnings) == 0      assert collector.infos[0] == Issue(IssueCollector._INFO_LEVEL, \"field\", 17, \"my message\", \"_ConfigChecker\")        MyCustomChecker(_Config(), collector)._info(\"foo\", \"bar\", \"baz\")      assert len(collector.all) == 2      assert len(collector.infos) == 2      assert len(collector.errors) == 0      assert len(collector.warnings) == 0      assert collector.infos[0] == Issue(IssueCollector._INFO_LEVEL, \"field\", 17, \"my message\", \"_ConfigChecker\")      assert collector.infos[1] == Issue(IssueCollector._INFO_LEVEL, \"foo\", \"bar\", \"baz\", \"MyCustomChecker\") "}
{"text": "from src.taipy.config import IssueCollector  from src.taipy.config.checker._checkers._config_checker import _ConfigChecker      class CheckerForTest(_ConfigChecker):      def _check(self) -> IssueCollector:          return self._collector "}
{"text": "from copy import copy  from typing import Any, Dict, List, Optional    from src.taipy.config import Config, Section  from src.taipy.config._config import _Config  from src.taipy.config.common._config_blocker import _ConfigBlocker    from .section_for_tests import SectionForTest      class SectionOfSectionsListForTest(Section):      name = \"list_section_name\"      _MY_ATTRIBUTE_KEY = \"attribute\"      _SECTIONS_LIST_KEY = \"sections_list\"        def __init__(self, id: str, attribute: Any = None, sections_list: List = None, **properties):          self._attribute = attribute          self._sections_list = sections_list if sections_list else []          super().__init__(id, **properties)        def __copy__(self):          return SectionOfSectionsListForTest(              self.id, self._attribute, copy(self._sections_list), **copy(self._properties)          )        @property      def attribute(self):          return self._replace_templates(self._attribute)        @attribute.setter  # type: ignore      @_ConfigBlocker._check()      def attribute(self, val):          self._attribute = val        @property      def sections_list(self):          return list(self._sections_list)        @sections_list.setter  # type: ignore      @_ConfigBlocker._check()      def sections_list(self, val):          self._sections_list = val        def _clean(self):          self._attribute = None          self._sections_list = []          self._properties.clear()        def _to_dict(self):          as_dict = {}          if self._attribute is not None:              as_dict[self._MY_ATTRIBUTE_KEY] = self._attribute          if self._sections_list:              as_dict[self._SECTIONS_LIST_KEY] = self._sections_list          as_dict.update(self._properties)          return as_dict        @classmethod      def _from_dict(cls, as_dict: Dict[str, Any], id: str, config: Optional[_Config] = None):          as_dict.pop(cls._ID_KEY, id)          attribute = as_dict.pop(cls._MY_ATTRIBUTE_KEY, None)          section_configs = config._sections.get(SectionForTest.name, None) or []  # type: ignore          sections_list = []          if inputs_as_str := as_dict.pop(cls._SECTIONS_LIST_KEY, None):              for section_id in inputs_as_str:                  if section_id in section_configs:                      sections_list.append(section_configs[section_id])                  else:                      sections_list.append(section_id)          return SectionOfSectionsListForTest(id=id, attribute=attribute, sections_list=sections_list, **as_dict)        def _update(self, as_dict: Dict[str, Any], default_section=None):          self._attribute = as_dict.pop(self._MY_ATTRIBUTE_KEY, self._attribute)          if self._attribute is None and default_section:              self._attribute = default_section._attribute          self._sections_list = as_dict.pop(self._SECTIONS_LIST_KEY, self._sections_list)          if self._sections_list is None and default_section:              self._sections_list = default_section._sections_list          self._properties.update(as_dict)          if default_section:              self._properties = {**default_section.properties, **self._properties}        @staticmethod      def _configure(id: str, attribute: str, sections_list: List = None, **properties):          section = SectionOfSectionsListForTest(id, attribute, sections_list, **properties)          Config._register(section)          return Config.sections[SectionOfSectionsListForTest.name][id] "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import os  import tempfile      class NamedTemporaryFile:      def __init__(self, content=None):          with tempfile.NamedTemporaryFile(\"w\", delete=False) as fd:              if content:                  fd.write(content)              self.filename = fd.name        def read(self):          with open(self.filename, \"r\") as fp:              return fp.read()        def __del__(self):          os.unlink(self.filename) "}
{"text": "from copy import copy  from typing import Any, Dict, Optional    from src.taipy.config import Config, Section  from src.taipy.config._config import _Config  from src.taipy.config.common._config_blocker import _ConfigBlocker      class SectionForTest(Section):      name = \"section_name\"      _MY_ATTRIBUTE_KEY = \"attribute\"        def __init__(self, id: str, attribute: Any = None, **properties):          self._attribute = attribute          super().__init__(id, **properties)        def __copy__(self):          return SectionForTest(self.id, self._attribute, **copy(self._properties))        @property      def attribute(self):          return self._replace_templates(self._attribute)        @attribute.setter  # type: ignore      @_ConfigBlocker._check()      def attribute(self, val):          self._attribute = val        def _clean(self):          self._attribute = None          self._properties.clear()        def _to_dict(self):          as_dict = {}          if self._attribute is not None:              as_dict[self._MY_ATTRIBUTE_KEY] = self._attribute          as_dict.update(self._properties)          return as_dict        @classmethod      def _from_dict(cls, as_dict: Dict[str, Any], id: str, config: Optional[_Config] = None):          as_dict.pop(cls._ID_KEY, id)          attribute = as_dict.pop(cls._MY_ATTRIBUTE_KEY, None)          return SectionForTest(id=id, attribute=attribute, **as_dict)        def _update(self, as_dict: Dict[str, Any], default_section=None):          self._attribute = as_dict.pop(self._MY_ATTRIBUTE_KEY, self._attribute)          if self._attribute is None and default_section:              self._attribute = default_section._attribute          self._properties.update(as_dict)          if default_section:              self._properties = {**default_section.properties, **self._properties}        @staticmethod      def _configure(id: str, attribute: str, **properties):          section = SectionForTest(id, attribute, **properties)          Config._register(section)          return Config.sections[SectionForTest.name][id] "}
{"text": "from copy import copy  from typing import Any, Dict, Optional    from src.taipy.config import Config  from src.taipy.config._config import _Config  from src.taipy.config.common._config_blocker import _ConfigBlocker  from src.taipy.config.unique_section import UniqueSection      class UniqueSectionForTest(UniqueSection):      name = \"unique_section_name\"      _MY_ATTRIBUTE_KEY = \"attribute\"        def __init__(self, attribute: str = None, **properties):          self._attribute = attribute          super().__init__(**properties)        def __copy__(self):          return UniqueSectionForTest(self._attribute, **copy(self._properties))        @property      def attribute(self):          return self._replace_templates(self._attribute)        @attribute.setter  # type: ignore      @_ConfigBlocker._check()      def attribute(self, val):          self._attribute = val        def _clean(self):          self._attribute = None          self._properties.clear()        def _to_dict(self):          as_dict = {}          if self._attribute is not None:              as_dict[self._MY_ATTRIBUTE_KEY] = self._attribute          as_dict.update(self._properties)          return as_dict        @classmethod      def _from_dict(cls, as_dict: Dict[str, Any], id=None, config: Optional[_Config] = None):          as_dict.pop(cls._ID_KEY, None)          attribute = as_dict.pop(cls._MY_ATTRIBUTE_KEY, None)          return UniqueSectionForTest(attribute=attribute, **as_dict)        def _update(self, as_dict: Dict[str, Any], default_section=None):          self._attribute = as_dict.pop(self._MY_ATTRIBUTE_KEY, self._attribute)          if self._attribute is None and default_section:              self._attribute = default_section._attribute          self._properties.update(as_dict)          if default_section:              self._properties = {**default_section.properties, **self._properties}        @staticmethod      def _configure(attribute: str, **properties):          section = UniqueSectionForTest(attribute, **properties)          Config._register(section)          return Config.unique_sections[UniqueSectionForTest.name] "}
{"text": "import pytest    from src.taipy.config.common._validate_id import _validate_id  from src.taipy.config.exceptions.exceptions import InvalidConfigurationId      class TestId:      def test_validate_id(self):          s = _validate_id(\"foo\")          assert s == \"foo\"          with pytest.raises(InvalidConfigurationId):              _validate_id(\"1foo\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"foo bar\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"foo/foo$\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\" \")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"class\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"def\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"with\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"CYCLE\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"SCENARIO\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"SEQUENCE\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"TASK\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"DATANODE\") "}
{"text": "import pytest    from src.taipy.config.common.scope import Scope      def test_scope():      # Test __ge__ method      assert Scope.GLOBAL >= Scope.GLOBAL      assert Scope.GLOBAL >= Scope.CYCLE      assert Scope.CYCLE >= Scope.CYCLE      assert Scope.GLOBAL >= Scope.SCENARIO      assert Scope.CYCLE >= Scope.SCENARIO      assert Scope.SCENARIO >= Scope.SCENARIO      with pytest.raises(TypeError):          assert Scope.SCENARIO >= \"testing string\"        # Test __gt__ method      assert Scope.GLOBAL > Scope.CYCLE      assert Scope.GLOBAL > Scope.SCENARIO      assert Scope.CYCLE > Scope.SCENARIO      with pytest.raises(TypeError):          assert Scope.SCENARIO > \"testing string\"        # Test __le__ method      assert Scope.GLOBAL <= Scope.GLOBAL      assert Scope.CYCLE <= Scope.GLOBAL      assert Scope.CYCLE <= Scope.CYCLE      assert Scope.SCENARIO <= Scope.GLOBAL      assert Scope.SCENARIO <= Scope.CYCLE      assert Scope.SCENARIO <= Scope.SCENARIO      with pytest.raises(TypeError):          assert Scope.SCENARIO <= \"testing string\"        # Test __lt__ method      assert Scope.SCENARIO < Scope.GLOBAL      assert Scope.SCENARIO < Scope.GLOBAL      assert Scope.SCENARIO < Scope.CYCLE      with pytest.raises(TypeError):          assert Scope.SCENARIO < \"testing string\" "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import argparse  import re  import sys    import pytest    from src.taipy._cli._base_cli import _CLI    if sys.version_info >= (3, 10):      argparse_options_str = \"options:\"  else:      argparse_options_str = \"optional arguments:\"      def preprocess_stdout(stdout):      stdout = stdout.replace(\"\\n\", \" \").replace(\"\\t\", \" \")      return re.sub(\" +\", \" \", stdout)      def remove_subparser(name: str):      \"\"\"Remove a subparser from argparse.\"\"\"      _CLI._sub_taipyparsers.pop(name, None)        if _CLI._subparser_action:          _CLI._subparser_action._name_parser_map.pop(name, None)            for action in _CLI._subparser_action._choices_actions:              if action.dest == name:                  _CLI._subparser_action._choices_actions.remove(action)      @pytest.fixture(autouse=True, scope=\"function\")  def clean_argparser():      _CLI._parser = argparse.ArgumentParser(conflict_handler=\"resolve\")      _CLI._arg_groups = {}      subcommands = list(_CLI._sub_taipyparsers.keys())      for subcommand in subcommands:          remove_subparser(subcommand)        yield      def test_subparser(capfd):      subcommand_1 = _CLI._add_subparser(\"subcommand_1\", help=\"subcommand_1 help\")      subcommand_1.add_argument(\"--foo\", \"-f\", help=\"foo help\")      subcommand_1.add_argument(\"--bar\", \"-b\", help=\"bar help\")        subcommand_2 = _CLI._add_subparser(\"subcommand_2\", help=\"subcommand_2 help\")      subcommand_2.add_argument(\"--doo\", \"-d\", help=\"doo help\")      subcommand_2.add_argument(\"--baz\", \"-z\", help=\"baz help\")        expected_subcommand_1_help_message = f\"\"\"subcommand_1 [-h] [--foo FOO] [--bar BAR]    {argparse_options_str}    -h, --help         show this help message and exit    --foo FOO, -f FOO  foo help    --bar BAR, -b BAR  bar help      \"\"\"        subcommand_1.print_help()      stdout, _ = capfd.readouterr()      assert preprocess_stdout(expected_subcommand_1_help_message) in preprocess_stdout(stdout)        expected_subcommand_2_help_message = f\"\"\"subcommand_2 [-h] [--doo DOO] [--baz BAZ]    {argparse_options_str}    -h, --help         show this help message and exit    --doo DOO, -d DOO  doo help    --baz BAZ, -z BAZ  baz help      \"\"\"        subcommand_2.print_help()      stdout, _ = capfd.readouterr()      assert preprocess_stdout(expected_subcommand_2_help_message) in preprocess_stdout(stdout)      def test_duplicate_subcommand():      subcommand_1 = _CLI._add_subparser(\"subcommand_1\", help=\"subcommand_1 help\")      subcommand_1.add_argument(\"--foo\", \"-f\", help=\"foo help\")        subcommand_2 = _CLI._add_subparser(\"subcommand_1\", help=\"subcommand_2 help\")      subcommand_2.add_argument(\"--bar\", \"-b\", help=\"bar help\")        # The title of subcommand_2 is duplicated with  subcommand_1, and therefore      # there will be no new subcommand created      assert len(_CLI._sub_taipyparsers) == 1      def test_groupparser(capfd):      group_1 = _CLI._add_groupparser(\"group_1\", \"group_1 desc\")      group_1.add_argument(\"--foo\", \"-f\", help=\"foo help\")      group_1.add_argument(\"--bar\", \"-b\", help=\"bar help\")        group_2 = _CLI._add_groupparser(\"group_2\", \"group_2 desc\")      group_2.add_argument(\"--doo\", \"-d\", help=\"doo help\")      group_2.add_argument(\"--baz\", \"-z\", help=\"baz help\")        expected_help_message = \"\"\"  group_1:    group_1 desc      --foo FOO, -f FOO  foo help    --bar BAR, -b BAR  bar help    group_2:    group_2 desc      --doo DOO, -d DOO  doo help    --baz BAZ, -z BAZ  baz help      \"\"\".strip()        _CLI._parser.print_help()      stdout, _ = capfd.readouterr()        assert expected_help_message in stdout      def test_duplicate_group():      group_1 = _CLI._add_groupparser(\"group_1\", \"group_1 desc\")      group_1.add_argument(\"--foo\", \"-f\", help=\"foo help\")        group_2 = _CLI._add_groupparser(\"group_1\", \"group_2 desc\")      group_2.add_argument(\"--bar\", \"-b\", help=\"bar help\")        # The title of group_2 is duplicated with  group_1, and therefore      # there will be no new group created      assert len(_CLI._arg_groups) == 1 "}
{"text": "import pytest    from src.taipy.config.common._classproperty import _Classproperty      class TestClassProperty:      def test_class_property(self):          class TestClass:              @_Classproperty              def test_property(cls):                  return \"test_property\"            assert TestClass.test_property == \"test_property\"          assert TestClass().test_property == \"test_property\"          with pytest.raises(TypeError):              TestClass.test_property() "}
{"text": "import os  from unittest import mock    import pytest    from src.taipy.config.config import Config  from src.taipy.config.exceptions.exceptions import ConfigurationUpdateBlocked      def test_global_config_with_env_variable_value():      with mock.patch.dict(os.environ, {\"FOO\": \"bar\", \"BAZ\": \"qux\"}):          Config.configure_global_app(foo=\"ENV[FOO]\", bar=\"ENV[BAZ]\")          assert Config.global_config.foo == \"bar\"          assert Config.global_config.bar == \"qux\"      def test_default_global_app_config():      global_config = Config.global_config      assert global_config is not None      assert not global_config.notification      assert len(global_config.properties) == 0      def test_block_update_global_app_config():      Config.block_update()        with pytest.raises(ConfigurationUpdateBlocked):          Config.configure_global_app(foo=\"bar\")        with pytest.raises(ConfigurationUpdateBlocked):          Config.global_config.properties = {\"foo\": \"bar\"}        # Test if the global_config stay as default      assert Config.global_config.foo is None      assert len(Config.global_config.properties) == 0 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import argparse  import re  from unittest.mock import patch    import pytest    from src.taipy._entrypoint import _entrypoint  from taipy._cli._base_cli import _CLI      def preprocess_stdout(stdout):      stdout = stdout.replace(\"\\n\", \" \").replace(\"\\t\", \" \")      return re.sub(\" +\", \" \", stdout)      def remove_subparser(name: str):      \"\"\"Remove a subparser from the _CLI class.\"\"\"      _CLI._sub_taipyparsers.pop(name, None)        if _CLI._subparser_action:          _CLI._subparser_action._name_parser_map.pop(name, None)            for action in _CLI._subparser_action._choices_actions:              if action.dest == name:                  _CLI._subparser_action._choices_actions.remove(action)      @pytest.fixture(autouse=True, scope=\"function\")  def clean_argparser():      _CLI._parser = argparse.ArgumentParser(conflict_handler=\"resolve\")      _CLI._subparser_action = None      _CLI._arg_groups = {}      subcommands = list(_CLI._sub_taipyparsers.keys())      for subcommand in subcommands:          remove_subparser(subcommand)        yield      expected_help = \"\"\"{run,manage-versions,create,migrate,help} ...    positional arguments:    {run,manage-versions,create,migrate,help}      run                 Run a Taipy application.      manage-versions     Taipy version control system.      create              Create a new Taipy application.      migrate             Migrate entities created from old taipy versions to be compatible with the current taipy      version. The entity migration should be performed only after updating taipy code to the current version.      help                Show the Taipy help message.  \"\"\"      def test_taipy_command_alone_print_help(capsys):      with patch(\"sys.argv\", [\"prog\"]):          _entrypoint()          out, _ = capsys.readouterr()          assert preprocess_stdout(expected_help) in preprocess_stdout(out)      def test_taipy_help_command(capsys):      with patch(\"sys.argv\", [\"prog\", \"help\"]):          with pytest.raises(SystemExit):              _entrypoint()          out, _ = capsys.readouterr()          assert preprocess_stdout(expected_help) in preprocess_stdout(out)      def test_help_non_existed_command(caplog):      with patch(\"sys.argv\", [\"prog\", \"help\", \"non_existed_command\"]):          with pytest.raises(SystemExit):              _entrypoint()          assert \"non_existed_command is not a valid command.\" in caplog.text      def test_taipy_create_help(capsys):      expected_help = \"create [-h] [--template\"        with patch(\"sys.argv\", [\"prog\", \"help\", \"create\"]):          with pytest.raises(SystemExit):              _entrypoint()          out, _ = capsys.readouterr()          assert preprocess_stdout(expected_help) in preprocess_stdout(out) "}
{"text": "import os  import sys  from importlib.util import find_spec  from pathlib import Path    import pandas as pd  # type: ignore  import pytest  from flask import Flask, g      def pytest_configure(config):      if (find_spec(\"src\") and find_spec(\"src.taipy\")) and (not find_spec(\"taipy\") or not find_spec(\"taipy.gui\")):          import src.taipy.gui          import src.taipy.gui._renderers.builder          import src.taipy.gui._warnings          import src.taipy.gui.builder          import src.taipy.gui.data.decimator.lttb          import src.taipy.gui.data.decimator.minmax          import src.taipy.gui.data.decimator.rdp          import src.taipy.gui.data.decimator.scatter_decimator          import src.taipy.gui.data.utils          import src.taipy.gui.extension          import src.taipy.gui.utils._map_dict          import src.taipy.gui.utils._variable_directory          import src.taipy.gui.utils.expr_var_name            sys.modules[\"taipy.gui._warnings\"] = sys.modules[\"src.taipy.gui._warnings\"]          sys.modules[\"taipy.gui._renderers.builder\"] = sys.modules[\"src.taipy.gui._renderers.builder\"]          sys.modules[\"taipy.gui.utils._variable_directory\"] = sys.modules[\"src.taipy.gui.utils._variable_directory\"]          sys.modules[\"taipy.gui.utils.expr_var_name\"] = sys.modules[\"src.taipy.gui.utils.expr_var_name\"]          sys.modules[\"taipy.gui.utils._map_dict\"] = sys.modules[\"src.taipy.gui.utils._map_dict\"]          sys.modules[\"taipy.gui.extension\"] = sys.modules[\"src.taipy.gui.extension\"]          sys.modules[\"taipy.gui.data.utils\"] = sys.modules[\"src.taipy.gui.data.utils\"]          sys.modules[\"taipy.gui.data.decimator.lttb\"] = sys.modules[\"src.taipy.gui.data.decimator.lttb\"]          sys.modules[\"taipy.gui.data.decimator.rdp\"] = sys.modules[\"src.taipy.gui.data.decimator.rdp\"]          sys.modules[\"taipy.gui.data.decimator.minmax\"] = sys.modules[\"src.taipy.gui.data.decimator.minmax\"]          sys.modules[\"taipy.gui.data.decimator.scatter_decimator\"] = sys.modules[              \"src.taipy.gui.data.decimator.scatter_decimator\"          ]          sys.modules[\"taipy.gui\"] = sys.modules[\"src.taipy.gui\"]          sys.modules[\"taipy.gui.builder\"] = sys.modules[\"src.taipy.gui.builder\"]      csv = pd.read_csv(      f\"{Path(Path(__file__).parent.resolve())}{os.path.sep}current-covid-patients-hospital.csv\", parse_dates=[\"Day\"]  )  small_dataframe_data = {\"name\": [\"A\", \"B\", \"C\"], \"value\": [1, 2, 3]}      @pytest.fixture(scope=\"function\")  def csvdata():      yield csv      @pytest.fixture(scope=\"function\")  def small_dataframe():      yield small_dataframe_data      @pytest.fixture(scope=\"function\")  def gui(helpers):      from taipy.gui import Gui        gui = Gui()      yield gui      # Delete Gui instance and state of some classes after each test      gui.stop()      helpers.test_cleanup()      @pytest.fixture  def helpers():      from .helpers import Helpers        return Helpers      @pytest.fixture  def test_client():      flask_app = Flask(\"Test App\")        # Create a test client using the Flask application configured for testing      with flask_app.test_client() as testing_client:          # Establish an application context          with flask_app.app_context():              g.client_id = \"test client id\"              yield testing_client  # this is where the testing happens! "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import inspect    from taipy.gui import Gui, Html      def test_simple_html(gui: Gui, helpers):      # html_string = \"<html><head></head><body><h1>test</h1><taipy:field value=\\\"test\\\"/></body></html>\"      html_string = \"<html><head></head><body><h1>test</h1></body></html>\"      gui._set_frame(inspect.currentframe())      gui.add_page(\"test\", Html(html_string))      gui.run(run_server=False)      client = gui._server.test_client()      jsx = client.get(\"/taipy-jsx/test\").json[\"jsx\"]      assert jsx == \"<h1>test</h1>\" "}
{"text": "import pytest    from taipy.gui import Gui      def test_invalid_control_name(gui: Gui, helpers):      md_string = \"<|invalid|invalid|>\"      expected_list = [\"INVALID SYNTAX - Control is 'invalid'\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_value_to_negated_property(gui: Gui, helpers):      md_string = \"<|button|not active=true|>\"      expected_list = [\"<Button\", \"active={false}\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_invalid_property_value(gui: Gui, helpers):      md_string = \"<|button|let's try that!|>\"      expected_list = [\"<Button\", 'label=\"&lt;Empty&gt;\"']      helpers.test_control_md(gui, md_string, expected_list)      def test_unclosed_block(gui: Gui, helpers):      md_string = \"<|\"      expected_list = [\"<Part\", \"</Part>\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_opening_unknown_block(gui: Gui, helpers):      md_string = \"<|unknown\"      expected_list = [\"<Part\", 'className=\"unknown\"']      helpers.test_control_md(gui, md_string, expected_list)      def test_closing_unknown_block(gui: Gui, helpers):      md_string = \"|>\"      expected_list = [\"<div>\", \"No matching opened tag\", \"</div>\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_md_link(gui: Gui, helpers):      md_string = \"[content](link)\"      expected_list = [\"<a\", 'href=\"link\"', \"content</a>\"]      helpers.test_control_md(gui, md_string, expected_list) "}
{"text": "import pytest    from taipy.gui.utils._bindings import _Bindings      def test_exception_binding_twice(gui, test_client):      bind = _Bindings(gui)      bind._new_scopes()      bind._bind(\"x\", 10)      with pytest.raises(ValueError):          bind._bind(\"x\", 10)      def test_exception_binding_invalid_name(gui):      bind = _Bindings(gui)      bind._new_scopes()      with pytest.raises(ValueError):          bind._bind(\"invalid identifier\", 10) "}
{"text": "from email import message    import pytest    from taipy.gui._page import _Page      def test_exception_page(gui):      page = _Page()      page._route = \"page1\"      with pytest.raises(RuntimeError, match=\"Can't render page page1: no renderer found\"):          page.render(gui) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import os  import tempfile  from unittest.mock import patch    import pytest    from taipy.config import Config  from taipy.config._config import _Config  from taipy.config._serializer._toml_serializer import _TomlSerializer  from taipy.config.checker._checker import _Checker  from taipy.config.checker.issue_collector import IssueCollector  from taipy.gui import Gui      class NamedTemporaryFile:      def __init__(self, content=None):          with tempfile.NamedTemporaryFile(\"w\", delete=False) as fd:              if content:                  fd.write(content)              self.filename = fd.name        def read(self):          with open(self.filename, \"r\") as fp:              return fp.read()        def __del__(self):          os.unlink(self.filename)      def init_config():      Config.unblock_update()      Config._default_config = _Config()._default_config()      Config._python_config = _Config()      Config._file_config = None      Config._env_file_config = None      Config._applied_config = _Config._default_config()      Config._collector = IssueCollector()      Config._serializer = _TomlSerializer()      _Checker._checkers = []        from taipy.config import _inject_section      from taipy.gui._default_config import default_config      from taipy.gui._gui_section import _GuiSection        _inject_section(          _GuiSection,          \"gui_config\",          _GuiSection(property_list=list(default_config)),          [(\"configure_gui\", _GuiSection._configure)],          add_to_unconflicted_sections=True,      )      @pytest.fixture(scope=\"function\", autouse=True)  def cleanup_test(helpers):      init_config()      helpers.test_cleanup()      yield      init_config()      helpers.test_cleanup()      def test_gui_service_arguments_hierarchy():      # Test default configuration      gui = Gui()      gui.run(run_server=False)      service_config = gui._config.config      assert not service_config[\"allow_unsafe_werkzeug\"]      assert service_config[\"async_mode\"] == \"gevent\"      assert service_config[\"change_delay\"] is None      assert service_config[\"chart_dark_template\"] is None      assert service_config[\"dark_mode\"]      assert service_config[\"dark_theme\"] is None      assert not service_config[\"debug\"]      assert not service_config[\"extended_status\"]      assert service_config[\"favicon\"] is None      assert not service_config[\"flask_log\"]      assert service_config[\"host\"] == \"127.0.0.1\"      assert service_config[\"light_theme\"] is None      assert service_config[\"margin\"] is None      assert service_config[\"ngrok_token\"] == \"\"      assert service_config[\"notification_duration\"] == 3000      assert service_config[\"propagate\"]      assert service_config[\"run_browser\"]      assert not service_config[\"run_in_thread\"]      assert not service_config[\"run_server\"]      assert not service_config[\"single_client\"]      assert not service_config[\"system_notification\"]      assert service_config[\"theme\"] is None      assert service_config[\"time_zone\"] is None      assert service_config[\"title\"] is None      assert service_config[\"upload_folder\"] is None      assert not service_config[\"use_arrow\"]      assert not service_config[\"use_reloader\"]      assert service_config[\"watermark\"] == \"Taipy inside\"      assert service_config[\"webapp_path\"] is None      assert service_config[\"port\"] == 5000      gui.stop()        # Override default configuration by explicit defined arguments in Gui.run()      gui = Gui()      gui.run(run_server=False, watermark=\"\", host=\"my_host\", port=5001)      service_config = gui._config.config      assert service_config[\"watermark\"] == \"\"      assert service_config[\"host\"] == \"my_host\"      assert service_config[\"port\"] == 5001      gui.stop()        # Override Gui.run() arguments by explicit defined arguments in Config.configure_gui()      Config.configure_gui(dark_mode=False, host=\"my_2nd_host\", port=5002)      gui = Gui()      gui.run(run_server=False, watermark=\"\", host=\"my_host\", port=5001)      service_config = gui._config.config      assert not service_config[\"dark_mode\"]      assert service_config[\"host\"] == \"my_2nd_host\"      assert service_config[\"watermark\"] == \"\"      assert service_config[\"port\"] == 5002      gui.stop()        # Override Config.configure_gui() arguments by loading a TOML file with [gui] section      toml_config = NamedTemporaryFile(          content=\"\"\"  [TAIPY]    [gui]  host = \"my_3rd_host\"  port = 5003  use_reloader = \"true:bool\"      \"\"\"      )      Config.load(toml_config.filename)      gui = Gui()      gui.run(run_server=False, host=\"my_host\", port=5001)      service_config = gui._config.config      assert service_config[\"host\"] == \"my_3rd_host\"      assert service_config[\"port\"] == 5003      assert service_config[\"use_reloader\"]      gui.stop()        # Override TOML configuration file with CLI arguments      with patch(\"sys.argv\", [\"prog\", \"--host\", \"my_4th_host\", \"--port\", \"5004\", \"--no-reloader\", \"--debug\"]):          gui = Gui()          gui.run(run_server=False, host=\"my_host\", port=5001)          service_config = gui._config.config          assert service_config[\"host\"] == \"my_4th_host\"          assert service_config[\"port\"] == 5004          assert not service_config[\"use_reloader\"]          assert service_config[\"debug\"]          gui.stop()      def test_clean_config():      gui_config = Config.configure_gui(dark_mode=False)        assert Config.gui_config is gui_config        gui_config._clean()        # Check if the instance before and after _clean() is the same      assert Config.gui_config is gui_config        assert gui_config.dark_mode is None      assert gui_config.properties == {} "}
{"text": "import inspect  import warnings    import pytest    from taipy.gui import Gui      def test_no_ignore_file(gui: Gui):      with warnings.catch_warnings(record=True):          gui._set_frame(inspect.currentframe())          gui.run(run_server=False)          client = gui._server.test_client()          response = client.get(\"/resource.txt\")          assert (              response.status_code == 200          ), f\"file resource.txt request status should be 200 but is {response.status_code}\" "}
{"text": "import inspect  import warnings    import pytest    from taipy.gui import Gui      def test_ignore_file_found(gui: Gui):      with warnings.catch_warnings(record=True):          gui._set_frame(inspect.currentframe())          gui.run(run_server=False)          client = gui._server.test_client()          response = client.get(\"/resource.txt\")          assert (              response.status_code == 404          ), f\"file resource.txt request status should be 404 but is {response.status_code}\"      def test_ignore_file_not_found(gui: Gui):      with warnings.catch_warnings(record=True):          gui._set_frame(inspect.currentframe())          gui.run(run_server=False)          client = gui._server.test_client()          response = client.get(\"/resource2.txt\")          assert (              response.status_code == 200          ), f\"file resource2.txt request status should be 200 but is {response.status_code}\" "}
{"text": "import inspect  import time  from urllib.request import urlopen    from taipy.gui import Gui      # this hangs in github  def test_run_thread(gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      gui.add_page(\"page1\", \"# first page\")      gui.run(run_in_thread=True, run_browser=False)      while not helpers.port_check():          time.sleep(0.1)      assert \">first page</h1>\" in urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\").read().decode(\"utf-8\")      gui.stop()      while helpers.port_check():          time.sleep(0.1)      gui.run(run_in_thread=True, run_browser=False)      while not helpers.port_check():          time.sleep(0.1)      assert \">first page</h1>\" in urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\").read().decode(\"utf-8\") "}
{"text": "import pytest    from taipy.gui import Gui      def test_add_shared_variables(gui: Gui):      Gui.add_shared_variable(\"var1\", \"var2\")      assert isinstance(gui._Gui__shared_variables, list)      assert len(gui._Gui__shared_variables) == 2        Gui.add_shared_variables(\"var1\", \"var2\")      assert len(gui._Gui__shared_variables) == 2 "}
{"text": "import json    from taipy.gui.gui import Gui      def test_multiple_instance():      gui1 = Gui(\"<|gui1|>\")      gui2 = Gui(\"<|gui2|>\")      gui1.run(run_server=False)      gui2.run(run_server=False)      client1 = gui1._server.test_client()      client2 = gui2._server.test_client()      assert_multiple_instance(client1, 'value=\"gui1\"')      assert_multiple_instance(client2, 'value=\"gui2\"')      def assert_multiple_instance(client, expected_value):      response = client.get(\"/taipy-jsx/TaiPy_root_page\")      response_data = json.loads(response.get_data().decode(\"utf-8\", \"ignore\"))      assert response.status_code == 200      assert isinstance(response_data, dict)      assert \"jsx\" in response_data      assert expected_value in response_data[\"jsx\"] "}
{"text": "from taipy.gui.utils._variable_directory import _MODULE_NAME_MAP, _variable_decode, _variable_encode      def test_variable_encode_decode():      assert _variable_encode(\"x\", \"module\") == \"x_TPMDL_0\"      assert _MODULE_NAME_MAP[0] == \"module\"      assert _variable_decode(\"x_TPMDL_0\") == (\"x\", \"module\")      assert _variable_encode(\"x\", None) == \"x\"      assert _variable_decode(\"x\") == (\"x\", None)      assert _variable_encode(\"TpExPr_x\", \"module1\") == \"TpExPr_x_TPMDL_1\"      assert _MODULE_NAME_MAP[1] == \"module1\"      assert _variable_decode(\"TpExPr_x_TPMDL_1\") == (\"x\", \"module1\") "}
{"text": "import inspect  import warnings    from taipy.gui import Gui, Markdown, State, navigate      def test_navigate(gui: Gui, helpers):      def navigate_to(state: State):          navigate(state, \"test\")        with warnings.catch_warnings(record=True):          gui._set_frame(inspect.currentframe())          gui.add_page(\"test\", Markdown(\"#This is a page\"))          gui.run(run_server=False)          client = gui._server.test_client()          # WS client and emit          ws_client = gui._server._ws.test_client(gui._server.get_flask())          # Get the jsx once so that the page will be evaluated -> variable will be registered          sid = helpers.create_scope_and_get_sid(gui)          client.get(f\"/taipy-jsx/test/?client_id={sid}\")          ws_client.emit(\"message\", {\"client_id\": sid, \"type\": \"A\", \"name\": \"my_button\", \"payload\": \"navigate_to\"})          # assert for received message (message that would be sent to the front-end client)          assert ws_client.get_received()      def test_navigate_to_no_route(gui: Gui, helpers):      def navigate_to(state: State):          navigate(state, \"toto\")        with warnings.catch_warnings(record=True):          gui._set_frame(inspect.currentframe())          gui.add_page(\"test\", Markdown(\"#This is a page\"))          gui.run(run_server=False)          client = gui._server.test_client()          # WS client and emit          ws_client = gui._server._ws.test_client(gui._server.get_flask())          # Get the jsx once so that the page will be evaluated -> variable will be registered          sid = helpers.create_scope_and_get_sid(gui)          client.get(f\"/taipy-jsx/test/?client_id={sid}\")          ws_client.emit(\"message\", {\"client_id\": sid, \"type\": \"A\", \"name\": \"my_button\", \"payload\": \"navigate_to\"})          # assert for received message (message that would be sent to the front-end client)          assert not ws_client.get_received()      def test_on_navigate_to_inexistant(gui: Gui, helpers):      def on_navigate(state: State, page: str):          return \"test2\" if page == \"test\" else page        with warnings.catch_warnings(record=True) as records:          gui._set_frame(inspect.currentframe())          gui.add_page(\"test\", Markdown(\"#This is a page\"))          gui.run(run_server=False)          client = gui._server.test_client()          # Get the jsx once so that the page will be evaluated -> variable will be registered          sid = helpers.create_scope_and_get_sid(gui)          client.get(f\"/taipy-jsx/test?client_id={sid}\")          warns = helpers.get_taipy_warnings(records)          assert len(warns) == 1          text = warns[0].message.args[0] if isinstance(warns[0].message, Warning) else warns[0].message          assert text == 'Cannot navigate to \"test2\": unknown page.'      def test_on_navigate_to_existant(gui: Gui, helpers):      def on_navigate(state: State, page: str):          return \"test2\" if page == \"test1\" else page        with warnings.catch_warnings(record=True):          gui._set_frame(inspect.currentframe())          gui.add_page(\"test1\", Markdown(\"#This is a page test1\"))          gui.add_page(\"test2\", Markdown(\"#This is a page test2\"))          gui.run(run_server=False)          client = gui._server.test_client()          # Get the jsx once so that the page will be evaluated -> variable will be registered          sid = helpers.create_scope_and_get_sid(gui)          content = client.get(f\"/taipy-jsx/test1?client_id={sid}\")          assert content.status_code == 302 "}
{"text": "import inspect    import pandas as pd  # type: ignore    from taipy.gui import Gui      def test_expression_text_control_str(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"Hello World!\")      md_string = \"<|{x}|>\"      expected_list = [\"<Field\", 'dataType=\"str\"', 'defaultValue=\"Hello World!\"', \"value={tpec_TpExPr_x_TPMDL_0}\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_expression_text_control_int(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      md_string = \"<|{x}|>\"      expected_list = [\"<Field\", 'dataType=\"int\"', 'defaultValue=\"10\"', \"value={tpec_TpExPr_x_TPMDL_0}\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_expression_text_control_1(gui: Gui, test_client, helpers):      gui._set_frame(inspect.currentframe())      gui._bind_var_val(\"x\", 10)      gui._bind_var_val(\"y\", 20)      md_string = \"<|{x + y}|>\"      expected_list = [          \"<Field\",          'dataType=\"int\"',          'defaultValue=\"30\"',          \"value={tp_TpExPr_x_y_TPMDL_0_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_expression_text_control_2(gui: Gui, test_client, helpers):      gui._set_frame(inspect.currentframe())      gui._bind_var_val(\"x\", 10)      gui._bind_var_val(\"y\", 20)      md_string = \"<|x + y = {x + y}|>\"      expected_list = [          \"<Field\",          'dataType=\"str\"',          'defaultValue=\"x + y = 30\"',          \"value={tp_TpExPr_x_y_x_y_TPMDL_0_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_expression_text_control_3(gui: Gui, test_client, helpers):      gui._set_frame(inspect.currentframe())      gui._bind_var_val(\"x\", \"Mickey Mouse\")      gui._bind_var_val(\"y\", \"Donald Duck\")      md_string = \"<|Hello {x} and {y}|>\"      expected_list = [          \"<Field\",          'dataType=\"str\"',          'defaultValue=\"Hello Mickey Mouse and Donald Duck\"',          \"value={tp_TpExPr_Hello_x_and_y_TPMDL_0_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_expression_text_gt_operator(gui: Gui, test_client, helpers):      gui._set_frame(inspect.currentframe())      gui._bind_var_val(\"x\", 0)      md_string = \"<|{x > 0}|>\"      expected_list = [          \"<Field\",          'dataType=\"bool\"',          'defaultValue=\"false\"',          \"value={tp_TpExPr_x_0_TPMDL_0_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_expression_button_control(gui: Gui, test_client, helpers):      gui._bind_var_val(\"label\", \"A button label\")      md_string = \"<|button|label={label}|>\"      expected_list = [\"<Button\", 'defaultLabel=\"A button label\"', \"label={tpec_TpExPr_label_TPMDL_0}\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_expression_table_control(gui: Gui, test_client, helpers):      gui._set_frame(inspect.currentframe())      gui._bind_var_val(\"pd\", pd)      gui._bind_var_val(\"series_1\", pd.Series([\"a\", \"b\", \"c\"], name=\"Letters\"))      gui._bind_var_val(\"series_2\", pd.Series([1, 2, 3], name=\"Numbers\"))      md_string = \"<|{pd.concat([series_1, series_2], axis=1)}|table|columns=Letters;Numbers|>\"      expected_list = [          \"<Table\",          'defaultColumns=\"{&quot;Letters&quot;: &#x7B;&quot;index&quot;: 0, &quot;type&quot;: &quot;object&quot;, &quot;dfid&quot;: &quot;Letters&quot;&#x7D;, &quot;Numbers&quot;: &#x7B;&quot;index&quot;: 1, &quot;type&quot;: &quot;int&quot;, &quot;dfid&quot;: &quot;Numbers&quot;&#x7D;}\"',          'updateVarName=\"_TpD_tp_TpExPr_pd_concat_series_1_series_2_axis_1_TPMDL_0_0\"',          \"data={_TpD_tp_TpExPr_pd_concat_series_1_series_2_axis_1_TPMDL_0_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      assert isinstance(gui._get_data_scope().tp_TpExPr_pd_concat_series_1_series_2_axis_1_TPMDL_0_0, pd.DataFrame)      def test_lambda_expression_selector(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"lov\",          [              {\"id\": \"1\", \"name\": \"scenario 1\"},              {\"id\": \"3\", \"name\": \"scenario 3\"},              {\"id\": \"2\", \"name\": \"scenario 2\"},          ],      )      gui._bind_var_val(\"sel\", {\"id\": \"1\", \"name\": \"scenario 1\"})      md_string = \"<|{sel}|selector|lov={lov}|type=test|adapter={lambda elt: (elt['id'], elt['name'])}|>\"      expected_list = [          \"<Selector\",          'defaultLov=\"[[&quot;1&quot;, &quot;scenario 1&quot;], [&quot;3&quot;, &quot;scenario 3&quot;], [&quot;2&quot;, &quot;scenario 2&quot;]]\"',          'defaultValue=\"[&quot;1&quot;]\"',          'updateVars=\"lov=_TpL_tpec_TpExPr_lov_TPMDL_0\"',          \"lov={_TpL_tpec_TpExPr_lov_TPMDL_0}\",          'updateVarName=\"_TpLv_tpec_TpExPr_sel_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_sel_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list) "}
{"text": "import numpy as np  import pandas as pd    from taipy.gui.data.decimator.lttb import LTTB  from taipy.gui.data.decimator.minmax import MinMaxDecimator  from taipy.gui.data.decimator.rdp import RDP  from taipy.gui.data.decimator.scatter_decimator import ScatterDecimator  from taipy.gui.data.utils import _df_data_filter      def test_data_filter_1(csvdata):      df, _ = _df_data_filter(csvdata[:1500], None, \"Daily hospital occupancy\", \"\", MinMaxDecimator(100), {}, False)      assert df.shape[0] == 100      def test_data_filter_2(csvdata):      df, _ = _df_data_filter(csvdata[:1500], None, \"Daily hospital occupancy\", \"\", LTTB(100), {}, False)      assert df.shape[0] == 100      def test_data_filter_3(csvdata):      df, _ = _df_data_filter(csvdata[:1500], None, \"Daily hospital occupancy\", \"\", RDP(n_out=100), {}, False)      assert df.shape[0] == 100      def test_data_filter_4(csvdata):      df, _ = _df_data_filter(csvdata[:1500], None, \"Daily hospital occupancy\", \"\", RDP(epsilon=100), {}, False)      assert df.shape[0] == 18      def test_data_filter_5(csvdata):      df, _ = _df_data_filter(          csvdata[:1500], None, \"Daily hospital occupancy\", \"\", ScatterDecimator(), {\"width\": 200, \"height\": 100}, False      )      assert df.shape[0] == 1150 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import inspect    import pytest    from taipy.gui import Gui, Markdown    from .state_asset.page1 import get_a, md_page1, set_a      def test_state(gui: Gui):      a = 10  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.add_page(\"page1\", md_page1)      gui.run(run_server=False, single_client=True)      state = gui._Gui__state      with gui.get_flask_app().app_context():          assert state.a == 10          assert state[\"page1\"].a == 20          assert state[\"tests.taipy.gui.gui_specific.state_asset.page1\"].a == 20          assert state._gui == gui          with pytest.raises(Exception) as e:              state.b          assert e.value.args[0] == \"Variable 'b' is not defined.\"            with pytest.raises(Exception) as e:              state.b = 10          assert e.value.args[0] == \"Variable 'b' is not accessible.\"            with pytest.raises(Exception) as e:              state._taipy_p1          assert e.value.args[0] == \"Variable '_taipy_p1' is protected and is not accessible.\"            with pytest.raises(Exception) as e:              state._taipy_p1 = 10          assert e.value.args[0] == \"Variable '_taipy_p1' is not accessible.\"            assert state._get_placeholder(\"_taipy_p1\") is None            state._set_placeholder(\"_taipy_p1\", 10)            assert state._get_placeholder(\"_taipy_p1\") == 10            assert state._get_placeholder_attrs() == (              \"_taipy_p1\",              \"_current_context\",          )            assert get_a(state) == 20            set_a(state, 30)            assert get_a(state) == 30 "}
{"text": "import pytest    from taipy.gui import Gui  from taipy.gui.utils._locals_context import _LocalsContext      def test_locals_context(gui: Gui):      lc = _LocalsContext()      gui.run(run_server=False)      with gui.get_flask_app().app_context():          with pytest.raises(KeyError):              lc.get_default()          current_locals = locals()          lc.set_default(current_locals)          assert lc.get_default() == current_locals          temp_locals = {\"__main__\": \"test\"}          lc.add(\"test\", temp_locals)          assert lc.get_context() is None          assert lc.get_locals() == current_locals          with lc.set_locals_context(\"test\"):              assert lc.get_context() == \"test\"              assert lc.get_locals() == temp_locals          assert lc.get_context() is None          assert lc.get_locals() == current_locals          assert lc.is_default() is True          assert \"__main__\" in lc.get_all_keys() "}
{"text": "import inspect    from taipy.gui.utils.get_module_name import _get_module_name_from_frame, _get_module_name_from_imported_var    x = 10      def test_get_module_name():      assert \"tests.taipy.gui.gui_specific.test_get_module_name\" == _get_module_name_from_frame(inspect.currentframe())      def test_get_module_name_imported_var():      assert \"tests.taipy.gui.gui_specific.test_get_module_name\" == _get_module_name_from_imported_var(          \"x\", 10, \"test_get_module_name\"      )      assert \"test_get_module_name\" == _get_module_name_from_imported_var(\"x\", 11, \"test_get_module_name\") "}
{"text": "import inspect  import os  from pathlib import Path    from taipy.gui import Gui      def test_folder_pages_binding(gui: Gui):      folder_path = f\"{Path(Path(__file__).parent.resolve())}{os.path.sep}sample_assets\"      gui._set_frame(inspect.currentframe())      gui.add_pages(folder_path)      gui.run(run_server=False)      assert len(gui._config.routes) == 3  # 2 files -> 2 routes + 1 default route      assert len(gui._config.pages) == 3  # 2 files -> 2 pages + 1 default page "}
{"text": "import inspect  import json  import warnings    from taipy.gui import Gui      def test_render_route(gui: Gui):      gui._set_frame(inspect.currentframe())      gui.add_page(\"page1\", \"# first page\")      gui.add_page(\"page2\", \"# second page\")      gui.run(run_server=False)      with warnings.catch_warnings(record=True):          client = gui._server.test_client()          response = client.get(\"/taipy-init\")          response_data = json.loads(response.get_data().decode(\"utf-8\", \"ignore\"))          assert response.status_code == 200          assert isinstance(response_data, dict)          assert isinstance(response_data[\"locations\"], dict)          assert \"/page1\" in response_data[\"locations\"]          assert \"/page2\" in response_data[\"locations\"]          assert \"/\" in response_data[\"locations\"]          assert response_data[\"locations\"] == {\"/\": \"/TaiPy_root_page\", \"/page1\": \"/page1\", \"/page2\": \"/page2\"} "}
{"text": "import json    import pandas as pd  import pytest    from taipy.gui import Gui  from taipy.gui.utils import _TaipyContent      def test__get_real_var_name(gui: Gui):      res = gui._get_real_var_name(\"\")      assert isinstance(res, tuple)      assert res[0] == \"\"      assert res[1] == \"\"        gui.run(run_server=False)      with gui.get_flask_app().app_context():          with pytest.raises(NameError):              res = gui._get_real_var_name(f\"{_TaipyContent.get_hash()}_var\")      def test__get_user_instance(gui: Gui):      gui.run(run_server=False)      with gui.get_flask_app().app_context():          with pytest.warns(UserWarning):              gui._get_user_instance(\"\", type(None))      def test__call_broadcast_callback(gui: Gui):      gui.run(run_server=False)      with gui.get_flask_app().app_context():          res = gui._call_broadcast_callback(lambda s, t: t, [\"Hello World\"], \"mine\")          assert res == \"Hello World\"        with gui.get_flask_app().app_context():          with pytest.warns(UserWarning):              res = gui._call_broadcast_callback(print, [\"Hello World\"], \"mine\")              assert res is None      def test__refresh_expr(gui: Gui):      gui.run(run_server=False)      with gui.get_flask_app().app_context():          res = gui._refresh_expr(\"var\", None)          assert res is None      def test__tbl_cols(gui: Gui):      data = pd.DataFrame({\"col1\": [0, 1, 2], \"col2\": [True, True, False]})      gui.run(run_server=False)      with gui.get_flask_app().app_context():          res = gui._tbl_cols(True, None, json.dumps({}), json.dumps({\"data\": \"data\"}), data=data)          d = json.loads(res)          assert isinstance(d, dict)          assert d[\"col1\"][\"type\"] == \"int\"            res = gui._tbl_cols(False, None, \"\", \"\")          assert repr(res) == \"Taipy: Do not update\"      def test__chart_conf(gui: Gui):      data = pd.DataFrame({\"col1\": [0, 1, 2], \"col2\": [True, True, False]})      gui.run(run_server=False)      with gui.get_flask_app().app_context():          res = gui._chart_conf(True, None, json.dumps({}), json.dumps({\"data\": \"data\"}), data=data)          d = json.loads(res)          assert isinstance(d, dict)          assert d[\"columns\"][\"col1\"][\"type\"] == \"int\"            res = gui._chart_conf(False, None, \"\", \"\")          assert repr(res) == \"Taipy: Do not update\"            with pytest.warns(UserWarning):              res = gui._chart_conf(True, None, \"\", \"\")              assert repr(res) == \"Taipy: Do not update\"      def test__get_valid_adapter_result(gui: Gui):      gui.run(run_server=False)      with gui.get_flask_app().app_context():          res = gui._get_valid_adapter_result((\"id\", \"label\"))          assert isinstance(res, tuple)          assert res[0] == \"id\" "}
{"text": "import json  import warnings  from types import SimpleNamespace    from taipy.gui import Gui, Markdown      def test_partial(gui: Gui):      with warnings.catch_warnings(record=True):          gui.add_partial(Markdown(\"#This is a partial\"))          gui.run(run_server=False)          client = gui._server.test_client()          response = client.get(f\"/taipy-jsx/{gui._config.partial_routes[0]}\")          response_data = json.loads(response.get_data().decode(\"utf-8\", \"ignore\"))          assert response.status_code == 200          assert \"jsx\" in response_data and \"This is a partial\" in response_data[\"jsx\"]      def test_partial_update(gui: Gui):      with warnings.catch_warnings(record=True):          partial = gui.add_partial(Markdown(\"#This is a partial\"))          gui.run(run_server=False, single_client=True)          client = gui._server.test_client()          response = client.get(f\"/taipy-jsx/{gui._config.partial_routes[0]}\")          response_data = json.loads(response.get_data().decode(\"utf-8\", \"ignore\"))          assert response.status_code == 200          assert \"jsx\" in response_data and \"This is a partial\" in response_data[\"jsx\"]          # update partial          fake_state = SimpleNamespace()          fake_state._gui = gui          partial.update_content(fake_state, \"#partial updated\")  # type: ignore          response = client.get(f\"/taipy-jsx/{gui._config.partial_routes[0]}\")          response_data = json.loads(response.get_data().decode(\"utf-8\", \"ignore\"))          assert response.status_code == 200          assert \"jsx\" in response_data and \"partial updated\" in response_data[\"jsx\"] "}
{"text": "from taipy.gui import Gui, Markdown      def test_variable_binding(helpers):      \"\"\"      Tests the binding of a few variables and a function      \"\"\"        def another_function(gui):          pass        x = 10      y = 20      z = \"button label\"      gui = Gui()      gui.add_page(\"test\", Markdown(\"<|{x}|> | <|{y}|> | <|{z}|button|on_action=another_function|>\"))      gui.run(run_server=False, single_client=True)      client = gui._server.test_client()      jsx = client.get(\"/taipy-jsx/test\").json[\"jsx\"]      for expected in [\"<Button\", 'defaultLabel=\"button label\"', \"label={tpec_TpExPr_z_TPMDL_0}\"]:          assert expected in jsx      assert gui._bindings().x == x      assert gui._bindings().y == y      assert gui._bindings().z == z      with gui.get_flask_app().app_context():          assert callable(gui._get_user_function(\"another_function\"))      helpers.test_cleanup()      def test_properties_binding(helpers):      gui = Gui()      modifier = \"nice \"  # noqa: F841      button_properties = {\"label\": \"A {modifier}button\"}  # noqa: F841      gui.add_page(\"test\", Markdown(\"<|button|properties=button_properties|>\"))      gui.run(run_server=False)      client = gui._server.test_client()      jsx = client.get(\"/taipy-jsx/test\").json[\"jsx\"]      for expected in [\"<Button\", 'defaultLabel=\"A nice button\"']:          assert expected in jsx      helpers.test_cleanup()      def test_dict_binding(helpers):      \"\"\"      Tests the binding of a dictionary property      \"\"\"      d = {\"k\": \"test\"}  # noqa: F841      gui = Gui(\"<|{d.k}|>\")      gui.run(run_server=False)      client = gui._server.test_client()      jsx = client.get(\"/taipy-jsx/TaiPy_root_page\").json[\"jsx\"]      for expected in [\"<Field\", 'defaultValue=\"test\"']:          assert expected in jsx      helpers.test_cleanup() "}
{"text": "from taipy.gui import Markdown    a = 20      def get_a(state):      return state.a      def set_a(state, val):      state.a = val      md_page1 = Markdown(      \"\"\"  <|{a}|>  \"\"\"  ) "}
{"text": "import inspect    import pytest    from taipy.gui import Gui  from taipy.gui.extension import Element, ElementLibrary      class MyLibrary(ElementLibrary):      def get_name(self) -> str:          return \"taipy_extension_example\"        def get_elements(self):          return dict()      def test_extension_no_config(gui: Gui, helpers):      gui.run(run_server=False, single_client=True)      flask_client = gui._server.test_client()      with pytest.warns(UserWarning):          ret = flask_client.get(\"/taipy-extension/toto/titi\")          assert ret.status_code == 404      def test_extension_config_wrong_path(gui: Gui, helpers):      Gui.add_library(MyLibrary())      gui.run(run_server=False, single_client=True)      flask_client = gui._server.test_client()      with pytest.warns(UserWarning):          ret = flask_client.get(\"/taipy-extension/taipy_extension_example/titi\")          assert ret.status_code == 404 "}
{"text": "import inspect    import pytest  from flask import g    from taipy.gui import Gui      def test_get_status(gui: Gui):      gui.run(run_server=False)      flask_client = gui._server.test_client()      ret = flask_client.get(\"/taipy.status.json\")      assert ret.status_code == 200, f\"status_code => {ret.status_code} != 200\"      assert ret.mimetype == \"application/json\", f\"mimetype => {ret.mimetype} != application/json\"      assert ret.json, \"json is not defined\"      assert \"gui\" in ret.json, \"json has no key gui\"      gui = ret.json.get(\"gui\")      assert isinstance(gui, dict), \"json.gui is not a dict\"      assert \"user_status\" in gui, \"json.gui has no key user_status\"      assert gui.get(\"user_status\") == \"\", \"json.gui.user_status is not empty\"      def test_get_extended_status(gui: Gui):      gui.run(run_server=False, extended_status=True)      flask_client = gui._server.test_client()      ret = flask_client.get(\"/taipy.status.json\")      assert ret.status_code == 200, f\"status_code => {ret.status_code} != 200\"      assert ret.mimetype == \"application/json\", f\"mimetype => {ret.mimetype} != application/json\"      assert ret.json, \"json is not defined\"      gui = ret.json.get(\"gui\")      assert \"backend_version\" in gui, \"json.gui has no key backend_version\"      assert \"flask_version\" in gui, \"json.gui has no key flask_version\"      assert \"frontend_version\" in gui, \"json.gui has no key frontend_version\"      assert \"host\" in gui, \"json.gui has no key host\"      assert \"python_version\" in gui, \"json.gui has no key python_version\"      assert \"user_status\" in gui, \"json.gui has no key user_status\"      assert gui.get(\"user_status\") == \"\", \"json.gui.user_status is not empty\"      def test_get_status_with_user_status(gui: Gui):      user_status = \"user_status\"        def on_status(state):          return user_status        gui._set_frame(inspect.currentframe())        gui.run(run_server=False)      flask_client = gui._server.test_client()      ret = flask_client.get(\"/taipy.status.json\")      assert ret.status_code == 200, f\"status_code => {ret.status_code} != 200\"      assert ret.json, \"json is not defined\"      gui = ret.json.get(\"gui\")      assert \"user_status\" in gui, \"json.gui has no key user_status\"      assert gui.get(\"user_status\") == user_status, f'json.gui.user_status => {gui.get(\"user_status\")} != {user_status}' "}
{"text": "import inspect  import io  import pathlib  import tempfile    import pytest    from taipy.gui import Gui  from taipy.gui.data.data_scope import _DataScopes  from taipy.gui.utils import _get_non_existent_file_path      def test_file_upload_no_varname(gui: Gui, helpers):      gui.run(run_server=False)      flask_client = gui._server.test_client()      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      with pytest.warns(UserWarning):          ret = flask_client.post(f\"/taipy-uploads?client_id={sid}\")          assert ret.status_code == 400      def test_file_upload_no_blob(gui: Gui, helpers):      gui.run(run_server=False)      flask_client = gui._server.test_client()      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      with pytest.warns(UserWarning):          ret = flask_client.post(f\"/taipy-uploads?client_id={sid}\", data={\"var_name\": \"varname\"})          assert ret.status_code == 400      def test_file_upload_no_filename(gui: Gui, helpers):      gui.run(run_server=False)      flask_client = gui._server.test_client()      file = (io.BytesIO(b\"abcdef\"), \"\")      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      with pytest.warns(UserWarning):          ret = flask_client.post(f\"/taipy-uploads?client_id={sid}\", data={\"var_name\": \"varname\", \"blob\": file})          assert ret.status_code == 400      def test_file_upload_simple(gui: Gui, helpers):      gui.run(run_server=False)      flask_client = gui._server.test_client()      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      file_name = \"test.jpg\"      file = (io.BytesIO(b\"abcdef\"), file_name)      upload_path = pathlib.Path(gui._get_config(\"upload_folder\", tempfile.gettempdir()))      file_name = _get_non_existent_file_path(upload_path, file_name).name      ret = flask_client.post(          f\"/taipy-uploads?client_id={sid}\",          data={\"var_name\": \"varname\", \"blob\": file},          content_type=\"multipart/form-data\",      )      assert ret.status_code == 200      created_file = upload_path / file_name      assert created_file.exists()      def test_file_upload_multi_part(gui: Gui, helpers):      gui.run(run_server=False)      flask_client = gui._server.test_client()      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      file_name = \"test2.jpg\"      file0 = (io.BytesIO(b\"abcdef\"), file_name)      file1 = (io.BytesIO(b\"abcdef\"), file_name)      upload_path = pathlib.Path(gui._get_config(\"upload_folder\", tempfile.gettempdir()))      file_name = _get_non_existent_file_path(upload_path, file_name).name      ret = flask_client.post(          f\"/taipy-uploads?client_id={sid}\",          data={\"var_name\": \"varname\", \"blob\": file0, \"total\": \"2\", \"part\": \"0\"},          content_type=\"multipart/form-data\",      )      assert ret.status_code == 200      file0_path = upload_path / f\"{file_name}.part.0\"      assert file0_path.exists()      ret = flask_client.post(          f\"/taipy-uploads?client_id={sid}\",          data={\"var_name\": \"varname\", \"blob\": file1, \"total\": \"2\", \"part\": \"1\"},          content_type=\"multipart/form-data\",      )      assert ret.status_code == 200      file1_path = upload_path / f\"{file_name}.part.1\"      assert file1_path.exists()      file_path = upload_path / file_name      assert file_path.exists()      def test_file_upload_multiple(gui: Gui, helpers):      var_name = \"varname\"      gui._set_frame(inspect.currentframe())      gui.run(run_server=False, single_client=True)      flask_client = gui._server.test_client()      with gui.get_flask_app().app_context():          gui._bind_var_val(var_name, None)      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = _DataScopes._GLOBAL_ID      file = (io.BytesIO(b\"abcdef\"), \"test.jpg\")      ret = flask_client.post(          f\"/taipy-uploads?client_id={sid}\", data={\"var_name\": var_name, \"blob\": file}, content_type=\"multipart/form-data\"      )      assert ret.status_code == 200      created_file = pathlib.Path(gui._get_config(\"upload_folder\", tempfile.gettempdir())) / \"test.jpg\"      assert created_file.exists()      file2 = (io.BytesIO(b\"abcdef\"), \"test2.jpg\")      ret = flask_client.post(          f\"/taipy-uploads?client_id={sid}\",          data={\"var_name\": var_name, \"blob\": file2, \"multiple\": \"True\"},          content_type=\"multipart/form-data\",      )      assert ret.status_code == 200      created_file = pathlib.Path(gui._get_config(\"upload_folder\", tempfile.gettempdir())) / \"test2.jpg\"      assert created_file.exists()      value = getattr(gui._bindings()._get_all_scopes()[sid], var_name)      assert len(value) == 2 "}
{"text": "import pathlib    import pytest    from taipy.gui import Gui      def test_image_path_not_found(gui: Gui, helpers):      gui.run(run_server=False)      flask_client = gui._server.test_client()      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      ret = flask_client.get(f\"/taipy-images/images/img.png?client_id={sid}\")      assert ret.status_code == 404      def test_image_path_found(gui: Gui, helpers):      url = gui._get_content(          \"img\", str((pathlib.Path(__file__).parent.parent.parent / \"resources\" / \"fred.png\").resolve()), True      )      gui.run(run_server=False)      flask_client = gui._server.test_client()      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      ret = flask_client.get(f\"{url}?client_id={sid}\")      assert ret.status_code == 200      def test_image_data_too_big(gui: Gui, helpers):      with open((pathlib.Path(__file__).parent.parent.parent / \"resources\" / \"taipan.jpg\"), \"rb\") as big_file:          url = gui._get_content(\"img\", big_file.read(), True)          assert not url.startswith(\"data:\") "}
{"text": "import inspect    import pytest    from taipy.gui import Gui      def test_user_content_without_callback(gui: Gui, helpers):      gui.run(run_server=False, single_client=True)      flask_client = gui._server.test_client()      with pytest.warns(UserWarning):          ret = flask_client.get(gui._get_user_content_url(\"path\"))          assert ret.status_code == 404      def test_user_content_with_wrong_callback(gui: Gui, helpers):      def on_user_content_cb(state, path, args):          return None        on_user_content = on_user_content_cb      gui._set_frame(inspect.currentframe())      gui.run(run_server=False, single_client=True)      flask_client = gui._server.test_client()      with pytest.warns(UserWarning):          ret = flask_client.get(gui._get_user_content_url(\"path\", {\"a\": \"b\"}))          assert ret.status_code == 404      def test_user_content_with_callback(gui: Gui, helpers):      def on_user_content_cb(state, path, args):          return \"\"        on_user_content = on_user_content_cb      gui._set_frame(inspect.currentframe())      gui.run(run_server=False, single_client=True)      flask_client = gui._server.test_client()      ret = flask_client.get(gui._get_user_content_url(\"path\"))      assert ret.status_code == 200 "}
{"text": "import inspect    from taipy.gui import Gui, Markdown  from taipy.gui.data.data_scope import _DataScopes      def test_sending_messages_in_group(gui: Gui, helpers):      name = \"World!\"  # noqa: F841      btn_id = \"button1\"  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|Hello {name}|button|id={btn_id}|>\"))      gui.run(run_server=False, single_client=True)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      cid = _DataScopes._GLOBAL_ID      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={cid}\")      assert gui._bindings()._get_all_scopes()[cid].name == \"World!\"  # type: ignore      assert gui._bindings()._get_all_scopes()[cid].btn_id == \"button1\"  # type: ignore        with gui.get_flask_app().test_request_context(f\"/taipy-jsx/test/?client_id={cid}\", data={\"client_id\": cid}):          with gui as aGui:              aGui._Gui__state.name = \"Monde!\"              aGui._Gui__state.btn_id = \"button2\"        assert gui._bindings()._get_all_scopes()[cid].name == \"Monde!\"      assert gui._bindings()._get_all_scopes()[cid].btn_id == \"button2\"  # type: ignore        received_messages = ws_client.get_received()      helpers.assert_outward_ws_multiple_message(received_messages[0], \"MS\", 2) "}
{"text": "import inspect  import logging  import pathlib    import pytest    from taipy.gui import Gui, download      def test_download_file(gui: Gui, helpers):      def do_something(state, id):          download(state, (pathlib.Path(__file__).parent.parent.parent / \"resources\" / \"taipan.jpg\"))        # Bind a page so that the function will be called      # gui.add_page(      #     \"test\", Markdown(\"<|Do something!|button|on_action=do_something|id=my_button|>\")      # )      # set gui frame      gui._set_frame(inspect.currentframe())        gui.run(run_server=False)      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      ws_client.emit(\"message\", {\"client_id\": sid, \"type\": \"A\", \"name\": \"my_button\", \"payload\": \"do_something\"})      # assert for received message (message that would be sent to the front-end client)      received_messages = ws_client.get_received()      assert len(received_messages) == 1      assert isinstance(received_messages[0], dict)      assert \"name\" in received_messages[0] and received_messages[0][\"name\"] == \"message\"      assert \"args\" in received_messages[0]      args = received_messages[0][\"args\"]      assert \"type\" in args and args[\"type\"] == \"DF\"      assert \"content\" in args and args[\"content\"] == \"/taipy-content/taipyStatic0/taipan.jpg\"      logging.getLogger().debug(args[\"content\"]) "}
{"text": "import inspect    from taipy.gui import Gui, Markdown      def ws_u_assert_template(gui: Gui, helpers, value_before_update, value_after_update, payload):      # Bind test variable      var = value_before_update  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        # Bind a page so that the variable will be evaluated as expression      gui.add_page(\"test\", Markdown(\"<|{var}|>\"))      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      flask_client.get(f\"/taipy-jsx/test?client_id={sid}\")      assert gui._bindings()._get_all_scopes()[sid].var == value_before_update      ws_client.emit(\"message\", {\"client_id\": sid, \"type\": \"U\", \"name\": \"tpec_TpExPr_var_TPMDL_0\", \"payload\": payload})      assert gui._bindings()._get_all_scopes()[sid].var == value_after_update      # assert for received message (message that would be sent to the front-end client)      received_message = ws_client.get_received()      assert len(received_message)      helpers.assert_outward_ws_message(received_message[0], \"MU\", \"tpec_TpExPr_var_TPMDL_0\", value_after_update)      def test_ws_u_string(gui: Gui, helpers):      value_before_update = \"a random string\"      value_after_update = \"a random string is added\"      payload = {\"value\": value_after_update}        # set gui frame      gui._set_frame(inspect.currentframe())        ws_u_assert_template(gui, helpers, value_before_update, value_after_update, payload)      def test_ws_u_number(gui: Gui, helpers):      value_before_update = 10      value_after_update = \"11\"      payload = {\"value\": value_after_update}        # set gui frame      gui._set_frame(inspect.currentframe())        ws_u_assert_template(gui, helpers, value_before_update, value_after_update, payload) "}
{"text": "import inspect    from taipy.gui import Gui, Markdown      def test_du_table_data_fetched(gui: Gui, helpers, csvdata):      # Bind test variables      csvdata = csvdata        # set gui frame      gui._set_frame(inspect.currentframe())      Gui._set_timezone(\"UTC\")        # Bind a page so that the variable will be evaluated as expression      gui.add_page(          \"test\",          Markdown(              \"<|{csvdata}|table|page_size=10|page_size_options=10;30;100|columns=Day;Entity;Code;Daily hospital occupancy|date_format=eee dd MMM yyyy|>\"          ),      )      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      sid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={sid}\")      ws_client.emit(          \"message\",          {              \"client_id\": sid,              \"type\": \"DU\",              \"name\": \"_TpD_tpec_TpExPr_csvdata_TPMDL_0\",              \"payload\": {                  \"columns\": [\"Day\", \"Entity\", \"Code\", \"Daily hospital occupancy\"],                  \"pagekey\": \"0-100--asc\",                  \"start\": 0,                  \"end\": 9,                  \"orderby\": \"\",                  \"sort\": \"asc\",              },          },      )      # assert for received message (message that would be sent to the front-end client)      received_messages = ws_client.get_received()      assert received_messages      helpers.assert_outward_ws_message(          received_messages[0],          \"MU\",          \"_TpD_tpec_TpExPr_csvdata_TPMDL_0\",          {              \"data\": [                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-01T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 856,                      \"Entity\": \"Austria\",                      \"_tp_index\": 0,                  },                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-02T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 823,                      \"Entity\": \"Austria\",                      \"_tp_index\": 1,                  },                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-03T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 829,                      \"Entity\": \"Austria\",                      \"_tp_index\": 2,                  },                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-04T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 826,                      \"Entity\": \"Austria\",                      \"_tp_index\": 3,                  },                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-05T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 712,                      \"Entity\": \"Austria\",                      \"_tp_index\": 4,                  },                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-06T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 824,                      \"Entity\": \"Austria\",                      \"_tp_index\": 5,                  },                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-07T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 857,                      \"Entity\": \"Austria\",                      \"_tp_index\": 6,                  },                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-08T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 829,                      \"Entity\": \"Austria\",                      \"_tp_index\": 7,                  },                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-09T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 820,                      \"Entity\": \"Austria\",                      \"_tp_index\": 8,                  },                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-10T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 771,                      \"Entity\": \"Austria\",                      \"_tp_index\": 9,                  },              ],              \"rowcount\": 14477,              \"start\": 0,              \"format\": \"JSON\",          },      ) "}
{"text": "import inspect    import pytest    from taipy.gui import Gui, Markdown      def test_default_on_change(gui: Gui, helpers):      st = {\"d\": False}        def on_change(state, var, value):          st[\"d\"] = True        x = 10  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|{x}|input|>\"))      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      flask_client.get(f\"/taipy-jsx/test?client_id={sid}\")      # fake var update      ws_client.emit(\"message\", {\"client_id\": sid, \"type\": \"U\", \"name\": \"x\", \"payload\": {\"value\": \"20\"}})      assert ws_client.get_received()      assert st[\"d\"] is True      def test_specific_on_change(gui: Gui, helpers):      st = {\"d\": False, \"s\": False}        def on_change(state, var, value):          st[\"d\"] = True        def on_input_change(state, var, value):          st[\"s\"] = True        x = 10  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|{x}|input|on_change=on_input_change|>\"))      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      flask_client.get(f\"/taipy-jsx/test?client_id={sid}\")      # fake var update      ws_client.emit(          \"message\",          {\"client_id\": sid, \"type\": \"U\", \"name\": \"x\", \"payload\": {\"value\": \"20\", \"on_change\": \"on_input_change\"}},      )      assert ws_client.get_received()      assert st[\"s\"] is True      assert st[\"d\"] is False "}
{"text": "import inspect    import pytest    from taipy.gui import Gui, Markdown      def test_ru_selector(gui: Gui, helpers, csvdata):      # Bind test variables      selected_val = [\"value1\", \"value2\"]  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        # Bind a page so that the variable will be evaluated as expression      gui.add_page(          \"test\",          Markdown(\"<|{selected_val}|selector|multiple|>\"),      )      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      sid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={sid}\")      ws_client.emit(\"message\", {\"client_id\": sid, \"type\": \"RU\", \"name\": \"\", \"payload\": {\"names\": [\"selected_val\"]}})      # assert for received message (message that would be sent to the front-end client)      received_messages = ws_client.get_received()      assert len(received_messages)      helpers.assert_outward_ws_message(received_messages[0], \"MU\", \"selected_val\", [\"value1\", \"value2\"]) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import inspect    import pytest    from taipy.gui import Gui, Markdown      def test_broadcast(gui: Gui, helpers):      # Bind test variables      selected_val = [\"value1\", \"value2\"]  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        # Bind a page so that the variable will be evaluated as expression      gui.add_page(          \"test\",          Markdown(\"<|{selected_val}|selector|multiple|>\"),      )      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      sid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={sid}\")      gui._broadcast(\"broadcast_name\", \"broadcast_value\")      received_messages = ws_client.get_received()      assert len(received_messages)      helpers.assert_outward_simple_ws_message(received_messages[0], \"U\", \"_bc_broadcast_name\", \"broadcast_value\") "}
{"text": "import inspect  import time    from taipy.gui import Gui, Markdown      def test_a_button_pressed(gui: Gui, helpers):      def do_something(state, id):          state.x = state.x + 10          state.text = \"a random text\"        x = 10  # noqa: F841      text = \"hi\"  # noqa: F841      # set gui frame      gui._set_frame(inspect.currentframe())      # Bind a page so that the variable will be evaluated as expression      gui.add_page(          \"test\", Markdown(\"<|Do something!|button|on_action=do_something|id=my_button|> | <|{x}|> | <|{text}|>\")      )      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      flask_client.get(f\"/taipy-jsx/test?client_id={sid}\")      assert gui._bindings()._get_all_scopes()[sid].x == 10  # type: ignore      assert gui._bindings()._get_all_scopes()[sid].text == \"hi\"  # type: ignore      ws_client.emit(\"message\", {\"client_id\": sid, \"type\": \"A\", \"name\": \"my_button\", \"payload\": \"do_something\"})      assert gui._bindings()._get_all_scopes()[sid].text == \"a random text\"      assert gui._bindings()._get_all_scopes()[sid].x == 20  # type: ignore      # assert for received message (message that would be sent to the front-end client)      received_messages = ws_client.get_received()      helpers.assert_outward_ws_message(received_messages[0], \"MU\", \"x\", 20)      helpers.assert_outward_ws_message(received_messages[1], \"MU\", \"text\", \"a random text\") "}
{"text": "import inspect  import warnings    from flask import g    from taipy.gui import Gui  from taipy.gui.utils.types import _TaipyNumber      def test_unbind_variable_in_expression(gui: Gui, helpers):      gui.run(run_server=False, single_client=True)      with warnings.catch_warnings(record=True) as records:          with gui.get_flask_app().app_context():              gui._evaluate_expr(\"{x}\")              warns = helpers.get_taipy_warnings(records)              assert len(warns) == 3              assert \"Variable 'x' is not available in\" in str(warns[0].message)              assert \"Variable 'x' is not defined\" in str(warns[1].message)              assert \"Cannot evaluate expression 'x'\" in str(warns[2].message)              assert \"name 'x' is not defined\" in str(warns[2].message)      def test_evaluate_same_expression_multiple_times(gui: Gui):      x = 10  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.run(run_server=False, single_client=True)      with gui.get_flask_app().app_context():          s1 = gui._evaluate_expr(\"x + 10 = {x + 10}\")          s2 = gui._evaluate_expr(\"x + 10 = {x + 10}\")          assert s1 == s2      def test_evaluate_expressions_same_variable(gui: Gui):      x = 10  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.run(run_server=False, single_client=True)      with gui.get_flask_app().app_context():          s1 = gui._evaluate_expr(\"x + 10 = {x + 10}\")          s2 = gui._evaluate_expr(\"x = {x}\")          assert \"tp_TpExPr_x\" in s1 and \"tp_TpExPr_x\" in s2      def test_evaluate_holder(gui: Gui):      x = 10  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.run(run_server=False, single_client=True)      with warnings.catch_warnings(record=True):          with gui.get_flask_app().app_context():              gui._evaluate_expr(\"{x + 10}\")              hash = gui._evaluate_bind_holder(_TaipyNumber, \"TpExPr_x + 10_TPMDL_0\")              assert \"_TpN_tp_TpExPr_x_10_TPMDL_0_0\" in hash              lst = gui._evaluate_holders(\"TpExPr_x + 10_TPMDL_0\")              assert len(lst) == 1              assert \"_TpN_tp_TpExPr_x_10_TPMDL_0_0\" in lst[0]              # test re-evaluate holders              gui._bindings().x = 20              gui._re_evaluate_expr(lst[0])      def test_evaluate_not_expression_type(gui: Gui):      gui.run(run_server=False)      with gui.get_flask_app().app_context():          assert \"x + 10\" == gui._evaluate_expr(\"x + 10\")      def test_evaluate_expression_2_clients(gui: Gui):      x = 10  # noqa: F841      y = 20  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.run(run_server=False)      with gui.get_flask_app().app_context():          gui._bindings()._get_or_create_scope(\"A\")          gui._bindings()._get_or_create_scope(\"B\")          g.client_id = \"A\"          gui._evaluate_expr(\"x + y = {x + y}\")          g.client_id = \"B\"          gui._evaluate_expr(\"x\")          gui._re_evaluate_expr(\"x\") "}
{"text": "import inspect    import pytest    from taipy.gui.gui import Gui  from taipy.gui.utils import _MapDict      def test_map_dict():      d = {\"a\": 1, \"b\": 2, \"c\": 3}      md = _MapDict(d)      md_copy = _MapDict(d).copy()      assert len(md) == 3      assert md.__getitem__(\"a\") == d[\"a\"]      md.__setitem__(\"a\", 4)      assert md.__getitem__(\"a\") == 4      assert d[\"a\"] == 4      v1 = d[\"b\"]      v2 = md.pop(\"b\")      assert v1 == v2      assert \"b\" not in d.keys()      assert \"c\" in md      assert len(md) == 2      v1 = d[\"c\"]      v2 = md.popitem()      assert v2 == (\"c\", v1)      assert len(md) == 1      md.clear()      assert len(md) == 0      assert len(d) == 0      assert len(md_copy) == 3      v1 = \"\"      for k in md_copy:          v1 += k      assert v1 == \"abc\"      v1 = \"\"      for k in md_copy.keys():          v1 += k      assert v1 == \"abc\"      v1 = \"\"      for k in md_copy.__reversed__():          v1 += k      assert v1 == \"cba\"      v1 = 0      for k in md_copy.values():          v1 += k      assert v1 == 6  # 1+2+3      v1 = md_copy.setdefault(\"a\", 5)      assert v1 == 1      v1 = md_copy.setdefault(\"d\", 5)      assert v1 == 5        try:          md = _MapDict(\"not_a_dict\")          assert False      except Exception:          assert True      pass      def test_map_dict_update():      update_values = {}        def update(k, v):          update_values[0] = k          update_values[1] = v          pass        d = {\"a\": 1, \"b\": \"2\"}      md = _MapDict(d, update)      md.__setitem__(\"a\", 3)      assert update_values[0] == \"a\"      assert update_values[1] == 3      pass      def test_map_dict_update_full_dictionary_1():      values = {\"a\": 1, \"b\": 2}      update_values = {\"a\": 3, \"b\": 5}      md = _MapDict(values)      assert md[\"a\"] == 1      assert md[\"b\"] == 2      md.update(update_values)      assert md[\"a\"] == 3      assert md[\"b\"] == 5      def test_map_dict_update_full_dictionary_2():      temp_values = {}        def update(k, v):          temp_values[k] = v        values = {\"a\": 1, \"b\": 2}      update_values = {\"a\": 3, \"b\": 5}      md = _MapDict(values, update)      assert md[\"a\"] == 1      assert md[\"b\"] == 2      md.update(update_values)      assert temp_values[\"a\"] == 3      assert temp_values[\"b\"] == 5      def test_map_dict_set(gui: Gui, test_client):      d = {\"a\": 1}  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        gui.run(run_server=False, single_client=True)      with gui.get_flask_app().app_context():          assert isinstance(gui._Gui__state.d, _MapDict)          gui._Gui__state.d = {\"b\": 2}          assert isinstance(gui._Gui__state.d, _MapDict)          assert len(gui._Gui__state.d) == 1          assert gui._Gui__state.d.get(\"a\", None) is None          assert gui._Gui__state.d.get(\"b\", None) == 2      def test_map_dict_items():      def update(k, v):          pass        values = {\"a\": 1, \"b\": {\"c\": \"list c\"}}      md = _MapDict(values)      mdu = _MapDict(values, update)      assert md[\"a\"] == 1      assert isinstance(md[\"b\"], _MapDict)      assert isinstance(mdu[\"b\"], _MapDict)      assert md[\"b\"][\"c\"] == \"list c\"      assert mdu[\"b\"][\"c\"] == \"list c\"      del md[\"a\"]      with pytest.raises(KeyError):          md[\"e\"]      setattr(md, \"a\", 1)      assert md[\"a\"] == 1 "}
{"text": "import pathlib  import tempfile    from taipy.gui import Gui  from taipy.gui.utils import _get_non_existent_file_path      def test_empty_file_name(gui: Gui, helpers):      assert _get_non_existent_file_path(pathlib.Path(tempfile.gettempdir()), \"\").name      def test_non_existent_file(gui: Gui, helpers):      assert not _get_non_existent_file_path(pathlib.Path(tempfile.gettempdir()), \"\").exists()      def test_existent_file(gui: Gui, helpers):      file_path = _get_non_existent_file_path(pathlib.Path(tempfile.gettempdir()), \"\")      with open(file_path, \"w\") as file_handler:          file_handler.write(\"hello\")      assert file_path.exists()      file_stem = file_path.stem.split(\".\", 1)[0]      file_suffix = file_path.suffixes[-1]      index = int(file_path.suffixes[0][1:]) if len(file_path.suffixes) > 1 else -1      file_path = _get_non_existent_file_path(pathlib.Path(tempfile.gettempdir()), \"\")      assert file_path.name == f\"{file_stem}.{index + 1}{file_suffix}\"      with open(file_path, \"w\") as file_handler:          file_handler.write(\"hello 2\")      assert file_path.exists()      file_path = _get_non_existent_file_path(pathlib.Path(tempfile.gettempdir()), \"\")      assert file_path.name == f\"{file_stem}.{index + 2}{file_suffix}\" "}
{"text": "  import warnings    import pytest    from taipy.gui.utils.date import _string_to_date  from taipy.gui.utils.types import _TaipyBase, _TaipyBool, _TaipyDate, _TaipyNumber      def test_taipy_base():      tb = _TaipyBase(\"value\", \"hash\")      assert tb.get() == \"value\"      assert tb.get_name() == \"hash\"      tb.set(\"a value\")      assert tb.get() == \"a value\"      assert tb.get_hash() == NotImplementedError      def test_taipy_bool():      assert _TaipyBool(0, \"v\").get() is False      assert _TaipyBool(1, \"v\").get() is True      assert _TaipyBool(False, \"v\").get() is False      assert _TaipyBool(True, \"v\").get() is True      assert _TaipyBool(\"\", \"v\").get() is False      assert _TaipyBool(\"hey\", \"v\").get() is True      assert _TaipyBool([], \"v\").get() is False      assert _TaipyBool([\"an item\"], \"v\").get() is True      def test_taipy_number():      with pytest.raises(TypeError):          _TaipyNumber(\"a string\", \"x\").get()      with warnings.catch_warnings(record=True):          _TaipyNumber(\"a string\", \"x\").cast_value(\"a string\")      _TaipyNumber(0, \"x\").cast_value(0)      def test_taipy_date():      assert _TaipyDate(_string_to_date(\"2022-03-03 00:00:00 UTC\"), \"x\").get() == \"2022-03-03T00:00:00+00:00\"      assert _TaipyDate(\"2022-03-03 00:00:00 UTC\", \"x\").get() == \"2022-03-03 00:00:00 UTC\"      assert _TaipyDate(None, \"x\").get() is None      _TaipyDate(\"\", \"x\").cast_value(\"2022-03-03 00:00:00 UTC\")      _TaipyDate(\"\", \"x\").cast_value(_string_to_date(\"2022-03-03 00:00:00 UTC\")) "}
{"text": "import inspect  from time import sleep    import pytest    from taipy.gui import Gui, State, invoke_long_callback      def test_long_callback(gui: Gui):      status = None  # noqa: F841        def heavy_function(delay=1):          sleep(delay)        def heavy_function_with_exception(delay=1):          sleep(delay)          raise Exception(\"Heavy function Exception\")        def heavy_function_status(state: State, status: int):          state.status = status        def on_exception(state: State, function_name: str, e: Exception):          state.status = -1        gui._set_frame(inspect.currentframe())      gui.run(run_server=False, single_client=True)      state = gui._Gui__state        with gui.get_flask_app().app_context():          assert state.status is None          invoke_long_callback(state, heavy_function)          invoke_long_callback(state, heavy_function_with_exception)          invoke_long_callback(state, heavy_function, (), heavy_function_status)          invoke_long_callback(state, heavy_function, (2), heavy_function_status, (), 1000)          invoke_long_callback(state, heavy_function_with_exception, (), heavy_function_status) "}
{"text": "import inspect    from flask import g    from taipy.gui import Gui, Markdown, get_state_id      def test_get_state_id(gui: Gui, helpers):      name = \"World!\"  # noqa: F841      btn_id = \"button1\"  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|Hello {name}|button|id={btn_id}|>\"))      gui.run(run_server=False)      flask_client = gui._server.test_client()      cid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={cid}\")      with gui.get_flask_app().app_context():          g.client_id = cid          assert cid == get_state_id(gui._Gui__state) "}
{"text": "import inspect    from flask import g    from taipy.gui import Gui, Markdown, State, download      def test_download(gui: Gui, helpers):      name = \"World!\"  # noqa: F841      btn_id = \"button1\"  # noqa: F841        def on_download_action(state: State):          pass        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|Hello {name}|button|id={btn_id}|>\"))      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      cid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={cid}\")      with gui.get_flask_app().test_request_context(f\"/taipy-jsx/test/?client_id={cid}\", data={\"client_id\": cid}):          g.client_id = cid          download(gui._Gui__state, \"some text\", \"filename.txt\", \"on_download_action\")        received_messages = ws_client.get_received()      helpers.assert_outward_ws_simple_message(          received_messages[0], \"DF\", {\"name\": \"filename.txt\", \"onAction\": \"on_download_action\"}      ) "}
{"text": "import inspect    from flask import g    from taipy.gui import Gui, Markdown, navigate      def test_navigate(gui: Gui, helpers):      name = \"World!\"  # noqa: F841      btn_id = \"button1\"  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|Hello {name}|button|id={btn_id}|>\"))      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      cid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={cid}\")      with gui.get_flask_app().test_request_context(f\"/taipy-jsx/test/?client_id={cid}\", data={\"client_id\": cid}):          g.client_id = cid          navigate(gui._Gui__state, \"test\")        received_messages = ws_client.get_received()      helpers.assert_outward_ws_simple_message(received_messages[0], \"NA\", {\"to\": \"test\"}) "}
{"text": "import inspect    from flask import g    from taipy.gui import Gui, Markdown, State, invoke_callback      def test_invoke_callback(gui: Gui, helpers):      name = \"World!\"  # noqa: F841      btn_id = \"button1\"  # noqa: F841        val = 1  # noqa: F841        def user_callback(state: State):          state.val = 10        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|Hello {name}|button|id={btn_id}|>\\n<|{val}|>\"))      gui.run(run_server=False, single_client=True)      flask_client = gui._server.test_client()      # client id      cid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={cid}\")      with gui.get_flask_app().app_context():          g.client_id = cid          invoke_callback(gui, cid, user_callback, [])          assert gui._Gui__state.val == 10 "}
{"text": "import inspect    from flask import g    from taipy.gui import Gui, Markdown, hold_control      def test_hold_control(gui: Gui, helpers):      name = \"World!\"  # noqa: F841      btn_id = \"button1\"  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|Hello {name}|button|id={btn_id}|>\"))      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      cid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={cid}\")      with gui.get_flask_app().test_request_context(f\"/taipy-jsx/test/?client_id={cid}\", data={\"client_id\": cid}):          g.client_id = cid          hold_control(gui._Gui__state)        received_messages = ws_client.get_received()      helpers.assert_outward_ws_simple_message(          received_messages[0], \"BL\", {\"action\": \"_taipy_on_cancel_block_ui\", \"message\": \"Work in Progress...\"}      ) "}
{"text": "import inspect    from flask import g    from taipy.gui import Gui, Markdown, resume_control      def test_resume_control(gui: Gui, helpers):      name = \"World!\"  # noqa: F841      btn_id = \"button1\"  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|Hello {name}|button|id={btn_id}|>\"))      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      cid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={cid}\")      with gui.get_flask_app().test_request_context(f\"/taipy-jsx/test/?client_id={cid}\", data={\"client_id\": cid}):          g.client_id = cid          resume_control(gui._Gui__state)        received_messages = ws_client.get_received()      helpers.assert_outward_ws_simple_message(received_messages[0], \"BL\", {\"message\": None}) "}
{"text": "import inspect    from flask import g    from taipy.gui import Gui, Markdown, notify      def test_notify(gui: Gui, helpers):      name = \"World!\"  # noqa: F841      btn_id = \"button1\"  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|Hello {name}|button|id={btn_id}|>\"))      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      cid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={cid}\")      with gui.get_flask_app().test_request_context(f\"/taipy-jsx/test/?client_id={cid}\", data={\"client_id\": cid}):          g.client_id = cid          notify(gui._Gui__state, \"Info\", \"Message\")        received_messages = ws_client.get_received()      helpers.assert_outward_ws_simple_message(received_messages[0], \"AL\", {\"atype\": \"Info\", \"message\": \"Message\"}) "}
{"text": "import contextlib  import time  from urllib.request import urlopen    import pytest  from testbook import testbook      @pytest.mark.filterwarnings(\"ignore::RuntimeWarning\")  @testbook(\"tests/gui/notebook/simple_gui.ipynb\")  def test_notebook_simple_gui(tb, helpers):      tb.execute_cell(\"import\")      tb.execute_cell(\"page_declaration\")      tb.execute_cell(\"gui_init\")      tb.execute_cell(\"gui_run\")      while not helpers.port_check():          time.sleep(0.1)      assert \">Hello</h1>\" in urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\").read().decode(\"utf-8\")      assert 'defaultValue=\\\\\"10\\\\\"' in urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\").read().decode(\"utf-8\")      # Test state manipulation within notebook      tb.execute_cell(\"get_variable\")      assert \"10\" in tb.cell_output_text(\"get_variable\")      assert 'defaultValue=\\\\\"10\\\\\"' in urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\").read().decode(\"utf-8\")      tb.execute_cell(\"set_variable\")      assert 'defaultValue=\\\\\"20\\\\\"' in urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\").read().decode(\"utf-8\")      tb.execute_cell(\"re_get_variable\")      assert \"20\" in tb.cell_output_text(\"re_get_variable\")      # Test page reload      tb.execute_cell(\"gui_stop\")      with pytest.raises(Exception) as exc_info:          urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\")      assert \"501: Gateway error\" in str(exc_info.value)      tb.execute_cell(\"gui_re_run\")      while True:          with contextlib.suppress(Exception):              urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\")              break      assert \">Hello</h1>\" in urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\").read().decode(\"utf-8\")      tb.execute_cell(\"gui_reload\")      while True:          with contextlib.suppress(Exception):              urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\")              break      assert \">Hello</h1>\" in urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\").read().decode(\"utf-8\")      tb.execute_cell(\"gui_re_stop\")      with pytest.raises(Exception) as exc_info:          urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\")      assert \"501: Gateway error\" in str(exc_info.value) "}
{"text": "from taipy.gui import Gui, Markdown "}
{"text": "import inspect  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      @pytest.mark.teste2e  def test_redirect(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|Redirect Successfully|id=text1|>  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui)      page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      text1 = page.query_selector(\"#text1\")      assert text1.inner_text() == \"Redirect Successfully\" "}
{"text": "import pytest      @pytest.fixture(scope=\"session\")  def browser_context_args(browser_context_args, e2e_port, e2e_base_url):      return {          **browser_context_args,          \"base_url\": f\"http://127.0.0.1:{e2e_port}{e2e_base_url}\",          \"timezone_id\": \"Europe/Paris\",      }      @pytest.fixture(scope=\"function\")  def gui(helpers, e2e_base_url):      from taipy.gui import Gui        gui = Gui()      gui.load_config({\"base_url\": e2e_base_url, \"host\": \"0.0.0.0\" if e2e_base_url != \"/\" else \"127.0.0.1\"})      yield gui      # Delete Gui instance and state of some classes after each test      gui.stop()      helpers.test_cleanup() "}
{"text": "import inspect  import re  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page      from playwright.sync_api import expect    from taipy.gui import Gui      @pytest.mark.teste2e  def test_navbar_navigate(page: \"Page\", gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"Data\", page=\"<|navbar|id=nav1|> <|Data|id=text-data|>\")      gui.add_page(name=\"Test\", page=\"<|navbar|id=nav1|> <|Test|id=text-test|>\")      helpers.run_e2e(gui)      page.goto(\"./Data\")      page.expect_websocket()      page.wait_for_selector(\"#text-data\")      page.click(\"#nav1 button:nth-child(2)\")      page.wait_for_selector(\"#text-test\")      expect(page).to_have_url(re.compile(\".*Test\"))      page.click(\"#nav1 button:nth-child(1)\")      page.wait_for_selector(\"#text-data\")      expect(page).to_have_url(re.compile(\".*Data\")) "}
{"text": "import inspect  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui  from taipy.gui.utils.date import _string_to_date      @pytest.mark.teste2e  def test_timzone_specified_1(page: \"Page\", gui: Gui, helpers):      _timezone_test_template(page, gui, helpers, \"Etc/GMT\", [\"2022-03-03 00:00:00 UTC\"])      @pytest.mark.teste2e  def test_timzone_specified_2(page: \"Page\", gui: Gui, helpers):      _timezone_test_template(          page, gui, helpers, \"Europe/Paris\", [\"2022-03-03 01:00:00 GMT+1\", \"2022-03-03 01:00:00 UTC+1\"]      )      @pytest.mark.teste2e  def test_timzone_specified_3(page: \"Page\", gui: Gui, helpers):      _timezone_test_template(          page, gui, helpers, \"Asia/Ho_Chi_Minh\", [\"2022-03-03 07:00:00 GMT+7\", \"2022-03-03 07:00:00 UTC+7\"]      )      @pytest.mark.teste2e  def test_timzone_specified_4(page: \"Page\", gui: Gui, helpers):      _timezone_test_template(          page, gui, helpers, \"America/Sao_Paulo\", [\"2022-03-02 21:00:00 GMT-3\", \"2022-03-02 21:00:00 UTC\u22123\"]      )      @pytest.mark.teste2e  def test_timezone_client_side(page: \"Page\", gui: Gui, helpers):      _timezone_test_template(page, gui, helpers, \"client\", [\"2022-03-03 01:00:00 GMT+1\", \"2022-03-03 01:00:00 UTC+1\"])      def _timezone_test_template(page: \"Page\", gui: Gui, helpers, time_zone, texts):      page_md = \"\"\"  <|{t}|id=text1|>  \"\"\"      t = _string_to_date(\"2022-03-03T00:00:00.000Z\")  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui, time_zone=time_zone)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      text1 = page.query_selector(\"#text1\")      assert text1.inner_text() in texts      def test_date_only(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|{t}|id=text1|>  \"\"\"      t = _string_to_date(\"Wed Jul 28 1993\")  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      text1 = page.query_selector(\"#text1\")      assert text1.inner_text() in [\"1993-07-28\"] "}
{"text": "import inspect  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      @pytest.mark.teste2e  def test_accessor_json(page: \"Page\", gui: Gui, csvdata, helpers):      table_data = csvdata  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.add_page(          name=\"test\",          page=\"<|{table_data}|table|columns=Day;Entity;Code;Daily hospital occupancy|date_format=eee dd MMM yyyy|id=table1|>\",      )      helpers.run_e2e(gui, use_arrow=False)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"#table1 tr:nth-child(32)\")  # wait for data to be loaded (30 rows of skeleton while loading)      assert_table_content(page)      @pytest.mark.teste2e  def test_accessor_arrow(page: \"Page\", gui: Gui, csvdata, helpers):      if util.find_spec(\"pyarrow\"):          table_data = csvdata  # noqa: F841          gui._set_frame(inspect.currentframe())          gui.add_page(              name=\"test\",              page=\"<|{table_data}|table|columns=Day;Entity;Code;Daily hospital occupancy|date_format=eee dd MMM yyyy|id=table1|>\",          )          helpers.run_e2e(gui, use_arrow=True)          page.goto(\"./test\")          page.expect_websocket()          page.wait_for_selector(              \"#table1 tr:nth-child(32)\"          )  # wait for data to be loaded (30 rows of skeleton while loading)          assert_table_content(page)      def assert_table_content(page: \"Page\"):      # assert page.query_selector(\"#table1 tbody tr:nth-child(1) td:nth-child(1)\").inner_text() == \"Wed 01 Apr 2020\"      assert page.query_selector(\"#table1 tbody tr:nth-child(1) td:nth-child(2)\").inner_text() == \"Austria\"      assert page.query_selector(\"#table1 tbody tr:nth-child(1) td:nth-child(4)\").inner_text() == \"856\" "}
{"text": "import inspect  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      @pytest.mark.teste2e  def test_theme_light(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|Just a page|id=text1|>  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui, dark_mode=False)      page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      background_color = page.evaluate(          'window.getComputedStyle(document.querySelector(\"main\"), null).getPropertyValue(\"background-color\")'      )      assert background_color == \"rgb(255, 255, 255)\"      @pytest.mark.teste2e  def test_theme_dark(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|Just a page|id=text1|>  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui, dark_mode=True)      page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      background_color = page.evaluate(          'window.getComputedStyle(document.querySelector(\"main\"), null).getPropertyValue(\"background-color\")'      )      assert background_color == \"rgb(18, 18, 18)\" "}
{"text": "import inspect  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      @pytest.mark.teste2e  def test_margin_1(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|Just a page|id=text1|>  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui, dark_mode=False, margin=\"10rem\")      page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      margin = page.evaluate('window.getComputedStyle(document.querySelector(\"#root\"), null).getPropertyValue(\"margin\")')      assert margin == \"160px\"      @pytest.mark.teste2e  def test_margin_2(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|Just a page|id=text1|>  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui, dark_mode=False)      page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      margin = page.evaluate('window.getComputedStyle(document.querySelector(\"#root\"), null).getPropertyValue(\"margin\")')      assert margin == \"16px\"      @pytest.mark.teste2e  def test_margin_3(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|Just a page|id=text1|>  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui, dark_mode=False, margin=\"10rem\", stylekit=True)      page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      margin = page.evaluate('window.getComputedStyle(document.querySelector(\"#root\"), null).getPropertyValue(\"margin\")')      assert margin == \"160px\"      @pytest.mark.teste2e  def test_margin_4(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|Just a page|id=text1|>  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui, dark_mode=False, stylekit={\"root_margin\": \"20rem\"})      page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      margin = page.evaluate('window.getComputedStyle(document.querySelector(\"#root\"), null).getPropertyValue(\"margin\")')      assert margin == \"320px\"      @pytest.mark.teste2e  def test_margin_5(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|Just a page|id=text1|>  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui, dark_mode=False, stylekit={\"root_margin\": \"20rem\"}, margin=\"10rem\")      page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      margin = page.evaluate('window.getComputedStyle(document.querySelector(\"#root\"), null).getPropertyValue(\"margin\")')      assert margin == \"320px\" "}
{"text": "import inspect  import os  import time  from importlib import util  from pathlib import Path  from urllib.request import urlopen    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui, Html  from taipy.gui.server import _Server      @pytest.mark.teste2e  def test_html_render_with_style(page: \"Page\", gui: Gui, helpers):      html_content = \"\"\"<!DOCTYPE html>  <html lang=\"en\">  <head>      <style>          .taipy-text {              color: green;          }          .custom-text {              color: blue;          }      </style>  </head>  <body>      <taipy:text id=\"text1\">Hey</taipy:text>      <taipy:text id=\"text2\" class=\"custom-text\">There</taipy:text>  </body>  </html>\"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(\"page1\", Html(html_content))      helpers.run_e2e(gui)      page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      retry = 0      while (          retry < 10          and page.evaluate('window.getComputedStyle(document.querySelector(\"#text1\"), null).getPropertyValue(\"color\")')          != \"rgb(0, 128, 0)\"      ):          retry += 1          time.sleep(0.2)      assert (          page.evaluate('window.getComputedStyle(document.querySelector(\"#text1\"), null).getPropertyValue(\"color\")')          == \"rgb(0, 128, 0)\"      )      assert (          page.evaluate('window.getComputedStyle(document.querySelector(\"#text2\"), null).getPropertyValue(\"color\")')          == \"rgb(0, 0, 255)\"      )      @pytest.mark.teste2e  def test_html_render_bind_assets(page: \"Page\", gui: Gui, helpers, e2e_base_url, e2e_port):      gui._set_frame(inspect.currentframe())      gui.add_pages(pages=f\"{Path(Path(__file__).parent.resolve())}{os.path.sep}test-assets\")      helpers.run_e2e(gui)      assert \".taipy-text\" in urlopen(          f\"http://127.0.0.1:{e2e_port}{e2e_base_url}test-assets/style/style.css\"      ).read().decode(\"utf-8\")      page.goto(\"./test-assets/page1\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      retry = 0      while (          retry < 10          and page.evaluate('window.getComputedStyle(document.querySelector(\"#text1\"), null).getPropertyValue(\"color\")')          != \"rgb(0, 128, 0)\"      ):          retry += 1          time.sleep(0.1)      assert (          page.evaluate('window.getComputedStyle(document.querySelector(\"#text1\"), null).getPropertyValue(\"color\")')          == \"rgb(0, 128, 0)\"      )      assert (          page.evaluate('window.getComputedStyle(document.querySelector(\"#text2\"), null).getPropertyValue(\"color\")')          == \"rgb(0, 0, 255)\"      )      @pytest.mark.teste2e  def test_html_render_path_mapping(page: \"Page\", gui: Gui, helpers, e2e_base_url, e2e_port):      gui._server = _Server(          gui,          path_mapping={\"style\": f\"{Path(Path(__file__).parent.resolve())}{os.path.sep}test-assets{os.path.sep}style\"},          flask=gui._flask,          async_mode=\"gevent\",      )      gui.add_page(\"page1\", Html(f\"{Path(Path(__file__).parent.resolve())}{os.path.sep}page1.html\"))      helpers.run_e2e(gui)      assert \".taipy-text\" in urlopen(f\"http://127.0.0.1:{e2e_port}{e2e_base_url}/style/style.css\").read().decode(\"utf-8\")      page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      retry = 0      while (          retry < 10          and page.evaluate('window.getComputedStyle(document.querySelector(\"#text1\"), null).getPropertyValue(\"color\")')          != \"rgb(0, 128, 0)\"      ):          retry += 1          time.sleep(0.1)      assert (          page.evaluate('window.getComputedStyle(document.querySelector(\"#text1\"), null).getPropertyValue(\"color\")')          == \"rgb(0, 128, 0)\"      )      assert (          page.evaluate('window.getComputedStyle(document.querySelector(\"#text2\"), null).getPropertyValue(\"color\")')          == \"rgb(0, 0, 255)\"      ) "}
{"text": "import inspect  import logging  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      @pytest.mark.teste2e  def test_markdown_render_with_style(page: \"Page\", gui: Gui, helpers):      markdown_content = \"\"\"  <|Hey|id=text1|>  <|There|id=text2|class_name=custom-text|>  \"\"\"      style = \"\"\"  .taipy-text {      color: green;  }  .custom-text {      color: blue;  }  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(\"page1\", markdown_content, style=style)      helpers.run_e2e(gui)      page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      page.wait_for_selector(\"#Taipy_style\", state=\"attached\")      function_evaluated = True      try:          page.wait_for_function(              'window.getComputedStyle(document.querySelector(\"#text1\"), null).getPropertyValue(\"color\") !== \"rgb(255, 255, 255)\"'          )      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          assert (              page.evaluate('window.getComputedStyle(document.querySelector(\"#text1\"), null).getPropertyValue(\"color\")')              == \"rgb(0, 128, 0)\"          )          assert (              page.evaluate('window.getComputedStyle(document.querySelector(\"#text2\"), null).getPropertyValue(\"color\")')              == \"rgb(0, 0, 255)\"          ) "}
{"text": "import inspect  import logging  from importlib import util    import pytest    from taipy.gui import Gui    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from .assets2_class_scopes.page1 import Page1  from .assets2_class_scopes.page2 import Page2      def helpers_assert_value(page, s1, s2, v1):      s1_val = page.input_value(\"#s1 input\")      assert str(s1_val).startswith(s1)      s2_val = page.input_value(\"#s2 input\")      assert str(s2_val).startswith(s2)      val1 = page.query_selector(\"#v1\").inner_text()      assert str(val1).startswith(v1)      @pytest.mark.timeout(300)  @pytest.mark.teste2e  @pytest.mark.filterwarnings(\"ignore::Warning\")  def test_class_scopes_binding(page: \"Page\", gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      operand_1 = 0  # noqa: F841      gui.add_page(\"page1\", Page1())      gui.add_page(\"page2\", Page2())      helpers.run_e2e(gui)        page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#s1\")      helpers_assert_value(page, \"0\", \"0\", \"0\")      page.fill(\"#s1 input\", \"15\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#v1').innerText !== '0'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_value(page, \"15\", \"0\", \"15\")      page.fill(\"#s2 input\", \"20\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#v1').innerText !== '15'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_value(page, \"15\", \"20\", \"35\")        page.goto(\"./page2\")      page.expect_websocket()      page.wait_for_selector(\"#s1\")      helpers_assert_value(page, \"15\", \"0\", \"0\")      page.fill(\"#s2 input\", \"5\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#v1').innerText !== '0'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_value(page, \"15\", \"5\", \"75\")      page.fill(\"#s1 input\", \"17\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#v1').innerText !== '75'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_value(page, \"17\", \"5\", \"85\")        page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#s1\")      helpers_assert_value(page, \"17\", \"20\", \"37\")        page.click(\"#btn_reset\")      try:          page.wait_for_function(\"document.querySelector('#v1').innerText !== '37'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_value(page, \"17\", \"0\", \"17\") "}
{"text": "import inspect  import logging  from importlib import util    import pytest    from taipy.gui import Gui    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from .assets.page1 import page as page1  from .assets.page2 import page as page2  from .assets.page3 import page as page3      @pytest.mark.timeout(300)  @pytest.mark.teste2e  def test_page_scopes(page: \"Page\", gui: Gui, helpers):      gui._set_frame(inspect.currentframe())        def on_change(state, var, val, module):          if var == \"x\" and \"page3\" in module:              state.y = val * 10        gui.add_page(\"page1\", page1)      gui.add_page(\"page2\", page2)      gui.add_page(\"page3\", page3)      helpers.run_e2e(gui)        page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#x1\")      assert page.query_selector(\"#x1\").inner_text() == \"10\"      assert page.query_selector(\"#x2\").inner_text() == \"20\"      assert page.query_selector(\"#y1\").inner_text() == \"20\"      assert page.query_selector(\"#y2\").inner_text() == \"40\"        page.goto(\"./page2\")      page.expect_websocket()      page.wait_for_selector(\"#x1\")      assert page.query_selector(\"#x1\").inner_text() == \"20\"      assert page.query_selector(\"#x2\").inner_text() == \"40\"      assert page.query_selector(\"#y1\").inner_text() == \"10\"      assert page.query_selector(\"#y2\").inner_text() == \"20\"        page.goto(\"./page3\")      page.expect_websocket()      page.wait_for_selector(\"#x1\")      assert page.query_selector(\"#x1\").inner_text() == \"50\"      assert page.query_selector(\"#x2\").inner_text() == \"100\"        page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#x1\")      page.fill(\"#xinput\", \"15\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#y2').innerText !== '40'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      assert page.query_selector(\"#x1\").inner_text() == \"15\"      assert page.query_selector(\"#x2\").inner_text() == \"30\"      assert page.query_selector(\"#y1\").inner_text() == \"45\"      assert page.query_selector(\"#y2\").inner_text() == \"90\"        page.goto(\"./page2\")      page.expect_websocket()      page.wait_for_selector(\"#x1\")      assert page.query_selector(\"#x1\").inner_text() == \"45\"      assert page.query_selector(\"#x2\").inner_text() == \"90\"      assert page.query_selector(\"#y1\").inner_text() == \"15\"      assert page.query_selector(\"#y2\").inner_text() == \"30\"      page.fill(\"#xinput\", \"37\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#y2').innerText !== '30'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      assert page.query_selector(\"#x1\").inner_text() == \"37\"      assert page.query_selector(\"#x2\").inner_text() == \"74\"      assert page.query_selector(\"#y1\").inner_text() == \"185\"      assert page.query_selector(\"#y2\").inner_text() == \"370\"        page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#x1\")      assert page.query_selector(\"#x1\").inner_text() == \"185\"      assert page.query_selector(\"#x2\").inner_text() == \"370\"      assert page.query_selector(\"#y1\").inner_text() == \"37\"      assert page.query_selector(\"#y2\").inner_text() == \"74\"        page.goto(\"./page3\")      page.expect_websocket()      page.wait_for_selector(\"#x1\")      assert page.query_selector(\"#x1\").inner_text() == \"50\"      assert page.query_selector(\"#x2\").inner_text() == \"100\" "}
{"text": "import inspect  import logging  from importlib import util    import pytest    from taipy.gui import Gui, Markdown    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from .assets3.page1 import page as page1      def helpers_assert_text(page, s):      val1 = page.query_selector(\"#t1\").inner_text()      assert str(val1).startswith(s)      # for issue #583  @pytest.mark.teste2e  @pytest.mark.filterwarnings(\"ignore::Warning\")  def test_page_scopes_main_var_access(page: \"Page\", gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      n = \"Hello\"  # noqa: F841        root_md = Markdown(          \"\"\"    <|{n}|input|id=i1|>    \"\"\"      )      gui.add_pages({\"/\": root_md, \"page1\": page1})      helpers.run_e2e(gui)        page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#t1\")      page.wait_for_selector(\"#i1\")      helpers_assert_text(page, \"Hello\")      page.fill(\"#i1\", \"Hello World\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#t1').innerText !== 'Hello'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_text(page, \"Hello World\") "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import inspect  import logging  from importlib import util    import pytest    from taipy.gui import Gui, Markdown    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from .assets3_class_scopes.page1 import Page1      def helpers_assert_text(page, s):      val1 = page.query_selector(\"#t1\").inner_text()      assert str(val1).startswith(s)      # for issue #583  @pytest.mark.teste2e  @pytest.mark.filterwarnings(\"ignore::Warning\")  def test_class_scopes_main_var_access(page: \"Page\", gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      n = \"Hello\"  # noqa: F841        root_md = Markdown(          \"\"\"    <|{n}|input|id=i1|>    \"\"\"      )      gui.add_pages({\"/\": root_md, \"page1\": Page1()})      helpers.run_e2e(gui)        page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#t1\")      page.wait_for_selector(\"#i1\")      helpers_assert_text(page, \"Hello\")      page.fill(\"#i1\", \"Hello World\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#t1').innerText !== 'Hello'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_text(page, \"Hello World\") "}
{"text": "import inspect  import logging  from importlib import util    import pytest    from taipy.gui import Gui    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from .assets4.page1 import page as page1  from .assets4.page1 import reset_d      @pytest.mark.timeout(300)  @pytest.mark.teste2e  @pytest.mark.filterwarnings(\"ignore::Warning\")  def test_page_scopes_state_runtime(page: \"Page\", gui: Gui, helpers):      gui._set_frame(inspect.currentframe())        def test(state):          reset_d(state)        def test2(state):          state[\"page1\"].d = 30        page_md = \"\"\"  <|button|on_action=test|id=btn1|>    <|button|on_action=test2|id=btn2|>  \"\"\"      gui.add_page(\"page1\", page1)      gui.add_page(name=Gui._get_root_page_name(), page=page_md)      helpers.run_e2e(gui)        page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#n1\")      text1 = page.query_selector(\"#t1\")      assert text1.inner_text() == \"20\"      page.fill(\"#n1\", \"21\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#t1').innerText !== '20'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      text1 = page.query_selector(\"#t1\")      assert text1.inner_text() == \"21\"        page.click(\"#btn1\")      try:          page.wait_for_function(\"document.querySelector('#t1').innerText !== '21'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      text1 = page.query_selector(\"#t1\")      assert text1.inner_text() == \"20\"        page.click(\"#btn2\")      try:          page.wait_for_function(\"document.querySelector('#t1').innerText !== '20'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      text1 = page.query_selector(\"#t1\")      assert text1.inner_text() == \"30\" "}
{"text": "import inspect  import logging  from importlib import util    import pytest    from taipy.gui import Gui    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from .assets2.page1 import page as page1  from .assets2.page2 import page as page2      def helpers_assert_value(page, s1, s2, v1):      s1_val = page.input_value(\"#s1 input\")      assert str(s1_val).startswith(s1)      s2_val = page.input_value(\"#s2 input\")      assert str(s2_val).startswith(s2)      val1 = page.query_selector(\"#v1\").inner_text()      assert str(val1).startswith(v1)      @pytest.mark.timeout(300)  @pytest.mark.teste2e  @pytest.mark.filterwarnings(\"ignore::Warning\")  def test_page_scopes_binding(page: \"Page\", gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      operand_1 = 0  # noqa: F841      gui.add_page(\"page1\", page1)      gui.add_page(\"page2\", page2)      helpers.run_e2e(gui)        page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#s1\")      helpers_assert_value(page, \"0\", \"0\", \"0\")      page.fill(\"#s1 input\", \"15\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#v1').innerText !== '0'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_value(page, \"15\", \"0\", \"15\")      page.fill(\"#s2 input\", \"20\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#v1').innerText !== '15'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_value(page, \"15\", \"20\", \"35\")        page.goto(\"./page2\")      page.expect_websocket()      page.wait_for_selector(\"#s1\")      helpers_assert_value(page, \"15\", \"0\", \"0\")      page.fill(\"#s2 input\", \"5\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#v1').innerText !== '0'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_value(page, \"15\", \"5\", \"75\")      page.fill(\"#s1 input\", \"17\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#v1').innerText !== '75'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_value(page, \"17\", \"5\", \"85\")        page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#s1\")      helpers_assert_value(page, \"17\", \"20\", \"37\") "}
{"text": "from taipy.gui import Markdown, Page      class Page1(Page):      def __init__(self):          self.operand_2 = 0          super().__init__()        def create_page(self):          return Markdown(\"page1.md\")        def reset(state):          state.operand_2 = 0 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from taipy.gui import Markdown, Page      class Page2(Page):      def __init__(self):          self.operand_2 = 0          super().__init__()        def create_page(self):          return Markdown(\"page2.md\") "}
{"text": "from taipy.gui import Markdown, Page      class Page1(Page):      def create_page(self):          return Markdown(              \"\"\"    <|{n}|id=t1|>    \"\"\"          ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from taipy.gui import Markdown    x = 10    y = 20      def on_change(state, var, val):      if var == \"x\":          state.y = val * 3      page = Markdown(      \"\"\"  x = <|{x}|id=x1|>    x * 2 = <|{x*2}|id=x2|>    x number: <|{x}|number|id=xinput|>    y = <|{y}|id=y1|>    y * 2 = <|{y*2}|id=y2|>  \"\"\"  ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from taipy.gui import Markdown    from .page1 import x as y  from .page1 import y as x      def on_change(state, var, val):      if var == \"x\":          state.y = val * 5      page = Markdown(      \"\"\"  y = <|{x}|id=x1|>    y * 2 = <|{x*2}|id=x2|>    y number: <|{x}|number|id=xinput|>    x = <|{y}|id=y1|>    x * 2 = <|{y*2}|id=y2|>  \"\"\"  ) "}
{"text": "from taipy.gui import Markdown    x = 50    page = Markdown(      \"\"\"  <|{x}|id=x1|>    x * 2 = <|{x*2}|id=x2|>    <|{x}|number|id=xinput|>  \"\"\"  ) "}
{"text": "from taipy.gui import Markdown    page = Markdown(      \"\"\"    # Page1 - Add    Operand 1: <|{operand_1}|slider|id=s1|>    Operand 2: <|{operand_2}|slider|id=s2|>    Operand 1 + Operand 2 = <|{operand_1 + operand_2}|id=v1|>  \"\"\"  )    operand_2 = 0 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from taipy.gui import Markdown    page = Markdown(      \"\"\"    # Page2 - Multiply    Operand 1: <|{operand_1}|slider|id=s1|>    Operand 2: <|{operand_2}|slider|id=s2|>    Operand 1 * Operand 2 = <|{operand_1 * operand_2}|id=v1|>  \"\"\"  )    operand_2 = 0 "}
{"text": "from taipy.gui import Markdown    d = 20      def reset_d(state):      state.d = d  # a      page = Markdown(      \"\"\"    <|{d}|text|id=t1|>    <|{d}|number|id=n1|>    \"\"\"  ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from taipy.gui import Markdown    page = Markdown(      \"\"\"    <|{n}|id=t1|>    \"\"\"  ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import inspect  import logging  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      @pytest.mark.teste2e  def test_slider_action(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|{x}|id=text1|>    <|{x}|slider|id=slider1|>  \"\"\"      x = 10  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      text1 = page.query_selector(\"#text1\")      assert text1.inner_text() == \"10\"      page.wait_for_selector(\"#slider1\")      page.fill(\"#slider1 input\", \"20\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#text1').innerText !== '10'\")      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          text1_2 = page.query_selector(\"#text1\")          assert text1_2.inner_text() == \"20\"      @pytest.mark.teste2e  def test_slider_action_on_change(page: \"Page\", gui: Gui, helpers):      d = {\"v1\": 10, \"v2\": 10}  # noqa: F841        def on_change(state, var, val):          if var == \"d.v2\":              d = {\"v1\": 2 * val}              state.d.update(d)        page_md = \"\"\"  Value: <|{d.v1}|id=text1|>    Slider: <|{d.v2}|slider|id=slider1|>  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      text1 = page.query_selector(\"#text1\")      assert text1.inner_text() == \"10\"      page.wait_for_selector(\"#slider1\")      page.fill(\"#slider1 input\", \"20\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#text1').innerText !== '10'\")      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          text1_2 = page.query_selector(\"#text1\")          assert text1_2.inner_text() == \"40\" "}
{"text": "import inspect  import logging  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      @pytest.mark.teste2e  def test_button_action(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|{x}|id=text1|>    <|Action|button|on_action=do_something_fn|id=button1|>  \"\"\"      x = 10  # noqa: F841        def do_something_fn(state):          state.x = state.x * 2        gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      text1 = page.query_selector(\"#text1\")      assert text1.inner_text() == \"10\"      page.click(\"#button1\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#text1').innerText !== '10'\")      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          text1_2 = page.query_selector(\"#text1\")          assert text1_2.inner_text() == \"20\" "}
{"text": "import inspect  import time  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui, State      @pytest.mark.teste2e  def test_selector_action(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|{x}|selector|lov=Item 1;Item 2;Item 3|id=selector1|>  \"\"\"      x = \"Item 1\"  # noqa: F841        def on_init(state: State):          assert state.x == \"Item 1\"        def on_change(state: State, var, val):          if var == \"x\":              assert val == \"Item 3\"        gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"ul#selector1\")      page.click('#selector1 > div[data-id=\"Item 3\"]')      page.wait_for_function(          \"document.querySelector('#selector1 > div[data-id=\\\"Item 3\\\"]').classList.contains('Mui-selected')\"      ) "}
{"text": "import inspect  import logging  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      def edit_and_assert_page(page: \"Page\"):      assert_input(page, \"0\")        page.fill(\"#input2 input\", \"20\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#val1').innerText !== '0'\")      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      assert_input(page, \"20\")        page.fill(\"#input1\", \"30\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#val1').innerText !== '20'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      assert_input(page, \"30\")      def assert_input(page: \"Page\", val: str):      val1 = page.query_selector(\"#val1\").inner_text()      assert str(val1).startswith(val)      val2 = page.query_selector(\"#val2\").inner_text()      assert str(val2).startswith(f\"Val: {val}\")      inp1 = page.input_value(\"input#input1\")      assert str(inp1).startswith(val)      inp2 = page.input_value(\"#input2 input\")      assert str(inp2).startswith(val)      @pytest.mark.filterwarnings(\"ignore::Warning\")  @pytest.mark.teste2e  def test_slider_input_reload(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  #Test Multi Number    <|{val}|id=val1|>    <|Val: {val}|id=val2|>    <|{val}|number|id=input1|>    <|{val}|slider|id=input2|>  \"\"\"      val = 0  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"page1\", page=page_md)      helpers.run_e2e_multi_client(gui)      page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#val1\")      edit_and_assert_page(page)        page.reload()      page.expect_websocket()      page.wait_for_selector(\"#val1\")      assert_input(page, \"30\")        page.evaluate(\"window.localStorage.removeItem('TaipyClientId')\")        page.reload()      page.expect_websocket()      page.wait_for_selector(\"#val1\")      assert_input(page, \"0\") "}
{"text": "import inspect  import logging  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      @pytest.mark.teste2e  def test_dict(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|{a_dict[a_key]}|input|id=inp1|>  <|{a_dict.key}|input|id=inp2|>  <|test|button|on_action=on_action_1|id=btn1|>  <|test|button|on_action=on_action_2|id=btn2|>  \"\"\"      a_key = \"key\"      a_dict = {a_key: \"Taipy\"}  # noqa: F841        def on_action_1(state):          state.a_dict.key = \"Hello\"        def on_action_2(state):          state.a_dict[state.a_key] = \"World\"        gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"#inp1\")        assert_text(page, \"Taipy\", \"Taipy\")        page.fill(\"input#inp1\", \"Taipy is the best\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#inp2').value !== 'Taipy'\")      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          assert_text(page, \"Taipy is the best\", \"Taipy is the best\")        page.fill(\"#inp2\", \"Taipy-Gui\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#inp1').value !== 'Taipy is the best'\")      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          assert_text(page, \"Taipy-Gui\", \"Taipy-Gui\")        page.click(\"#btn1\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#inp1').value !== 'Taipy-Gui'\")      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          assert_text(page, \"Hello\", \"Hello\")        page.click(\"#btn2\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#inp1').value !== 'Hello'\")      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          assert_text(page, \"World\", \"World\")      def assert_text(page, inp1, inp2):      assert page.input_value(\"input#inp1\") == inp1      assert page.input_value(\"input#inp2\") == inp2 "}
{"text": "import inspect  import logging  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      @pytest.mark.teste2e  def test_text_edit(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|{x}|text|id=text1|>    <|{x}|input|id=input1|>  \"\"\"      x = \"Hey\"  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      text1 = page.query_selector(\"#text1\")      assert text1.inner_text() == \"Hey\"      page.wait_for_selector(\"#input1\")      page.fill(\"#input1\", \"There\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#text1').innerText !== 'Hey'\")      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          text1_2 = page.query_selector(\"#text1\")          assert text1_2.inner_text() == \"There\"      @pytest.mark.teste2e  def test_number_edit(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|{x}|text|id=text1|>    <|{x}|number|id=number1|>    \"\"\"      x = 10  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      text1 = page.query_selector(\"#text1\")      assert text1.inner_text() == \"10\"      page.wait_for_selector(\"#number1\")      page.fill(\"#number1\", \"20\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#text1').innerText !== '10'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          text1_2 = page.query_selector(\"#text1\")          assert text1_2.inner_text() == \"20\" "}
{"text": "from importlib import util    from taipy.gui import Gui  from taipy.gui.data.array_dict_data_accessor import _ArrayDictDataAccessor  from taipy.gui.data.data_format import _DataFormat  from taipy.gui.utils import _MapDict    an_array = [1, 2, 3]      def test_simple_data(gui: Gui, helpers):      accessor = _ArrayDictDataAccessor()      ret_data = accessor.get_data(gui, \"x\", an_array, {\"start\": 0, \"end\": -1}, _DataFormat.JSON)      assert ret_data      value = ret_data[\"value\"]      assert value      assert value[\"rowcount\"] == 3      data = value[\"data\"]      assert len(data) == 3      def test_simple_data_with_arrow(gui: Gui, helpers):      if util.find_spec(\"pyarrow\"):          accessor = _ArrayDictDataAccessor()          ret_data = accessor.get_data(gui, \"x\", an_array, {\"start\": 0, \"end\": -1}, _DataFormat.APACHE_ARROW)          assert ret_data          value = ret_data[\"value\"]          assert value          assert value[\"rowcount\"] == 3          data = value[\"data\"]          assert isinstance(data, bytes)      def test_slice(gui: Gui, helpers):      accessor = _ArrayDictDataAccessor()      value = accessor.get_data(gui, \"x\", an_array, {\"start\": 0, \"end\": 1}, _DataFormat.JSON)[\"value\"]      assert value[\"rowcount\"] == 3      data = value[\"data\"]      assert len(data) == 2      value = accessor.get_data(gui, \"x\", an_array, {\"start\": \"0\", \"end\": \"1\"}, _DataFormat.JSON)[\"value\"]      data = value[\"data\"]      assert len(data) == 2      def test_sort(gui: Gui, helpers):      accessor = _ArrayDictDataAccessor()      a_dict = {\"name\": [\"A\", \"B\", \"C\"], \"value\": [3, 2, 1]}      query = {\"columns\": [\"name\", \"value\"], \"start\": 0, \"end\": -1, \"orderby\": \"name\", \"sort\": \"desc\"}      data = accessor.get_data(gui, \"x\", a_dict, query, _DataFormat.JSON)[\"value\"][\"data\"]      assert data[0][\"name\"] == \"C\"      def test_aggregate(gui: Gui, helpers, small_dataframe):      accessor = _ArrayDictDataAccessor()      a_dict = {\"name\": [\"A\", \"B\", \"C\", \"A\"], \"value\": [3, 2, 1, 2]}      query = {\"columns\": [\"name\", \"value\"], \"start\": 0, \"end\": -1, \"aggregates\": [\"name\"], \"applies\": {\"value\": \"sum\"}}      value = accessor.get_data(gui, \"x\", a_dict, query, _DataFormat.JSON)[\"value\"]      assert value[\"rowcount\"] == 3      data = value[\"data\"]      agregValue = next(v.get(\"value\") for v in data if v.get(\"name\") == \"A\")      assert agregValue == 5      def test_array_of_array(gui: Gui, helpers, small_dataframe):      accessor = _ArrayDictDataAccessor()      an_array = [[1, 2, 3], [2, 4, 6]]      ret_data = accessor.get_data(gui, \"x\", an_array, {\"start\": 0, \"end\": -1}, _DataFormat.JSON)      assert ret_data      value = ret_data[\"value\"]      assert value      assert value[\"rowcount\"] == 2      data = value[\"data\"]      assert len(data) == 2      assert len(data[0]) == 4  # including _tp_index      def test_empty_array(gui: Gui, helpers, small_dataframe):      accessor = _ArrayDictDataAccessor()      an_array: list[str] = []      ret_data = accessor.get_data(gui, \"x\", an_array, {\"start\": 0, \"end\": -1}, _DataFormat.JSON)      assert ret_data      value = ret_data[\"value\"]      assert value      assert value[\"rowcount\"] == 0      data = value[\"data\"]      assert len(data) == 0      def test_array_of_diff_array(gui: Gui, helpers, small_dataframe):      accessor = _ArrayDictDataAccessor()      an_array = [[1, 2, 3], [2, 4]]      ret_data = accessor.get_data(gui, \"x\", an_array, {\"start\": 0, \"end\": -1, \"alldata\": True}, _DataFormat.JSON)      assert ret_data      value = ret_data[\"value\"]      assert value      assert value[\"multi\"] is True      data = value[\"data\"]      assert len(data) == 2      assert len(data[0][\"0/0\"]) == 3      assert len(data[1][\"1/0\"]) == 2      def test_array_of_dicts(gui: Gui, helpers, small_dataframe):      accessor = _ArrayDictDataAccessor()      an_array_of_dicts = [          {              \"temperatures\": [                  [17.2, 27.4, 28.6, 21.5],                  [5.6, 15.1, 20.2, 8.1],                  [26.6, 22.8, 21.8, 24.0],                  [22.3, 15.5, 13.4, 19.6],                  [3.9, 18.9, 25.7, 9.8],              ],              \"cities\": [\"Hanoi\", \"Paris\", \"Rio de Janeiro\", \"Sydney\", \"Washington\"],          },          {\"seasons\": [\"Winter\", \"Summer\", \"Spring\", \"Autumn\"]},      ]      ret_data = accessor.get_data(          gui, \"x\", an_array_of_dicts, {\"start\": 0, \"end\": -1, \"alldata\": True}, _DataFormat.JSON      )      assert ret_data      value = ret_data[\"value\"]      assert value      assert value[\"multi\"] is True      data = value[\"data\"]      assert len(data) == 2      assert len(data[0][\"temperatures\"]) == 5      assert len(data[1][\"seasons\"]) == 4      def test_array_of_Mapdicts(gui: Gui, helpers, small_dataframe):      accessor = _ArrayDictDataAccessor()      dict1 = _MapDict(          {              \"temperatures\": [                  [17.2, 27.4, 28.6, 21.5],                  [5.6, 15.1, 20.2, 8.1],                  [26.6, 22.8, 21.8, 24.0],                  [22.3, 15.5, 13.4, 19.6],                  [3.9, 18.9, 25.7, 9.8],              ],              \"cities\": [\"Hanoi\", \"Paris\", \"Rio de Janeiro\", \"Sydney\", \"Washington\"],          }      )      dict2 = _MapDict({\"seasons\": [\"Winter\", \"Summer\", \"Spring\", \"Autumn\"]})      ret_data = accessor.get_data(gui, \"x\", [dict1, dict2], {\"start\": 0, \"end\": -1, \"alldata\": True}, _DataFormat.JSON)      assert ret_data      value = ret_data[\"value\"]      assert value      assert value[\"multi\"] is True      data = value[\"data\"]      assert len(data) == 2      assert len(data[0][\"temperatures\"]) == 5      assert len(data[1][\"seasons\"]) == 4 "}
{"text": "import inspect    import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_slider_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      with tgb.Page(frame=None) as page:          tgb.slider(value=\"{x}\")      expected_list = [          \"<Slider\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0',          \"defaultValue={10}\",          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_slider_with_min_max_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 0)      with tgb.Page(frame=None) as page:          tgb.slider(value=\"{x}\", min=-10, max=10)      expected_list = [\"<Slider\", \"min={-10.0}\", \"max={10.0}\", \"defaultValue={0}\"]      helpers.test_control_builder(gui, page, expected_list)      def test_slider_with_dict_labels_builder(gui: Gui, helpers):      sel = \"Item 1\"  # noqa: F841      labels = {\"Item 1\": \"Label Start\", \"Item 3\": \"Label End\"}  # noqa: F841      gui._set_frame(inspect.currentframe())      with tgb.Page(frame=None) as page:          tgb.slider(value=\"{sel}\", lov=\"Item 1;Item 2;Item 3\", labels=labels)      expected_list = [          \"<Slider\",          'labels=\"{&quot;Item 1&quot;: &quot;Label Start&quot;, &quot;Item 3&quot;: &quot;Label End&quot;}\"',      ]      helpers.test_control_builder(gui, page, expected_list)      def test_slider_with_boolean_labels_builder(gui: Gui, helpers):      sel = \"Item 1\"  # noqa: F841      gui._set_frame(inspect.currentframe())      with tgb.Page(frame=None) as page:          tgb.slider(value=\"{sel}\", lov=\"Item 1;Item 2;Item 3\", labels=True)      expected_list = [\"<Slider\", \"labels={true}\"]      helpers.test_control_builder(gui, page, expected_list)      def test_slider_items_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"Item 1\")      with tgb.Page(frame=None) as page:          tgb.slider(value=\"{x}\", lov=\"Item 1;Item 2;Item 3\", text_anchor=\"left\")      expected_list = [          \"<Slider\",          'updateVarName=\"_TpLv_tpec_TpExPr_x_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_x_TPMDL_0}\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'textAnchor=\"left\"',      ]      helpers.test_control_builder(gui, page, expected_list)      def test_slider_text_anchor_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"Item 1\")      with tgb.Page(frame=None) as page:          tgb.slider(value=\"{x}\", text_anchor=None)      expected_list = [          \"<Slider\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",          'textAnchor=\"none\"',      ]      helpers.test_control_builder(gui, page, expected_list)      def test_slider_text_anchor_default_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"Item 1\")      with tgb.Page(frame=None) as page:          tgb.slider(value=\"{x}\", items=\"Item 1\")      expected_list = [          \"<Slider\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",          'textAnchor=\"bottom\"',      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_button_builder_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"name\", \"World!\")      gui._bind_var_val(\"btn_id\", \"button1\")      with tgb.Page(frame=None) as page:          tgb.button(label=\"Hello {name}\", id=\"{btn_id}\")      expected_list = [\"<Button\", 'defaultLabel=\"Hello World!\"', \"label={tp_TpExPr_Hello_name_TPMDL_0_0\"]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_selector_builder_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"selected_val\", [\"l1\", \"l2\"])      gui._bind_var_val(\"selector_properties\", {\"lov\": [(\"l1\", \"v1\"), (\"l2\", \"v2\"), (\"l3\", \"v3\")], \"filter\": True})      with tgb.Page(frame=None) as page:          tgb.selector(value=\"{selected_val}\", properties=\"{selector_properties}\", multiple=True)      expected_list = [          \"<Selector\",          'defaultLov=\"[[&quot;l1&quot;, &quot;v1&quot;], [&quot;l2&quot;, &quot;v2&quot;], [&quot;l3&quot;, &quot;v3&quot;]]\"',          'defaultValue=\"[&quot;l1&quot;, &quot;l2&quot;]\"',          \"filter={true}\",          \"multiple={true}\",          'updateVarName=\"_TpLv_tpec_TpExPr_selected_val_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_val_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_selector_builder_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"selected_val\", \"Item 2\")      with tgb.Page(frame=None) as page:          tgb.selector(value=\"{selected_val}\", lov=\"Item 1;Item 2; This is a another value\")      expected_list = [          \"<Selector\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot; This is a another value&quot;]\"',          'defaultValue=\"[&quot;Item 2&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_selected_val_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_val_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_selector_builder_3(gui: Gui, test_client, helpers):      gui._bind_var_val(\"elt\", None)      gui._bind_var_val(          \"scenario_list\",          [{\"id\": \"1\", \"name\": \"scenario 1\"}, {\"id\": \"3\", \"name\": \"scenario 3\"}, {\"id\": \"2\", \"name\": \"scenario 2\"}],      )      gui._bind_var_val(\"selected_obj\", {\"id\": \"1\", \"name\": \"scenario 1\"})      with tgb.Page(frame=None) as page:          tgb.selector(              value=\"{selected_obj}\",              lov=\"{scenario_list}\",              adapter=\"{lambda elt: (elt['id'], elt['name'])}\",              propagate=False,          )      expected_list = [          \"<Selector\",          'defaultLov=\"[[&quot;1&quot;, &quot;scenario 1&quot;], [&quot;3&quot;, &quot;scenario 3&quot;], [&quot;2&quot;, &quot;scenario 2&quot;]]\"',          'defaultValue=\"[&quot;1&quot;]\"',          \"lov={_TpL_tpec_TpExPr_scenario_list_TPMDL_0}\",          \"propagate={false}\",          'updateVars=\"lov=_TpL_tpec_TpExPr_scenario_list_TPMDL_0\"',          'updateVarName=\"_TpLv_tpec_TpExPr_selected_obj_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_obj_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import inspect    import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_input_builder(gui: Gui, helpers):      x = \"Hello World!\"  # noqa: F841      gui._set_frame(inspect.currentframe())      with tgb.Page(frame=None) as page:          tgb.input(value=\"{x}\")      expected_list = [          \"<Input\",          'updateVarName=\"tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"Hello World!\"',          'type=\"text\"',          \"value={tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_password_builder(gui: Gui, helpers):      x = \"Hello World!\"  # noqa: F841      gui._set_frame(inspect.currentframe())      with tgb.Page(frame=None) as page:          tgb.input(value=\"{x}\", password=True)      expected_list = [          \"<Input\",          'updateVarName=\"tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"Hello World!\"',          'type=\"password\"',          \"value={tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_tree_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"value\", \"Item 1\")      with tgb.Page(frame=None) as page:          tgb.tree(value=\"{value}\", lov=\"Item 1;Item 2;Item 3\")      expected_list = [          \"<TreeView\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_value_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_value_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_tree_expanded_builder_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"value\", \"Item 1\")      with tgb.Page(frame=None) as page:          tgb.tree(value=\"{value}\", lov=\"Item 1;Item 2;Item 3\", expanded=False)      expected_list = [          \"<TreeView\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_value_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_value_TPMDL_0}\",          \"expanded={false}\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_tree_expanded_builder_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"value\", \"Item 1\")      gui._bind_var_val(\"expa\", [\"Item1\"])      with tgb.Page(frame=None) as page:          tgb.tree(value=\"{value}\", lov=\"Item 1;Item 2;Item 3\", expanded=\"{expa}\")      expected_list = [          \"<TreeView\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_value_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_value_TPMDL_0}\",          'defaultExpanded=\"[&quot;Item1&quot;]\"',          \"expanded={tpec_TpExPr_expa_TPMDL_0}\",          'updateVars=\"expanded=tpec_TpExPr_expa_TPMDL_0',      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_expandable_builder_1(gui: Gui, helpers):      with tgb.expandable(title=\"Expandable section\", expanded=False) as content:          tgb.text(value=\"This is an expandable section\")      expected_list = [          \"<Expandable\",          \"expanded={false}\",          'title=\"Expandable section\"',          \"This is an expandable section\",      ]      helpers.test_control_builder(gui, tgb.Page(content, frame=None), expected_list) "}
{"text": "import inspect    import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_table_builder_1(gui: Gui, helpers, csvdata):      with tgb.Page(frame=None) as page:          tgb.table(              data=\"{csvdata}\",              page_size=10,              page_size_options=[10, 30, 100],              columns=[\"Day\", \"Entity\", \"Code\", \"Daily hospital occupancy\"],              date_format=\"eee dd MMM yyyy\",          )      expected_list = [          \"<Table\",          'defaultColumns=\"{&quot;Entity&quot;: &#x7B;&quot;index&quot;: 1, &quot;type&quot;: &quot;object&quot;, &quot;dfid&quot;: &quot;Entity&quot;&#x7D;, &quot;Code&quot;: &#x7B;&quot;index&quot;: 2, &quot;type&quot;: &quot;object&quot;, &quot;dfid&quot;: &quot;Code&quot;&#x7D;, &quot;Daily hospital occupancy&quot;: &#x7B;&quot;index&quot;: 3, &quot;type&quot;: &quot;int&quot;, &quot;dfid&quot;: &quot;Daily hospital occupancy&quot;&#x7D;, &quot;Day_str&quot;: &#x7B;&quot;index&quot;: 0, &quot;type&quot;: &quot;datetime&quot;, &quot;dfid&quot;: &quot;Day&quot;, &quot;format&quot;: &quot;eee dd MMM yyyy&quot;&#x7D;}\"',          'height=\"80vh\"',          'width=\"100%\"',          'pageSizeOptions=\"[10, 30, 100]\"',          \"pageSize={10.0}\",          \"selected={[]}\",          'updateVarName=\"_TpD_tpec_TpExPr_csvdata_TPMDL_0\"',          \"data={_TpD_tpec_TpExPr_csvdata_TPMDL_0}\",      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_builder(gui, page, expected_list)      def test_table_reset_builder(gui: Gui, helpers, csvdata):      with tgb.Page(frame=None) as page:          tgb.table(              data=\"{csvdata}\",              rebuild=True,              page_size=10,              page_size_options=\"10;30;100\",              columns=\"Day;Entity;Code;Daily hospital occupancy\",              date_format=\"eee dd MMM yyyy\",          )      expected_list = [          \"<Table\",          'defaultColumns=\"{&quot;Entity&quot;: &#x7B;&quot;index&quot;: 1, &quot;type&quot;: &quot;object&quot;, &quot;dfid&quot;: &quot;Entity&quot;&#x7D;, &quot;Code&quot;: &#x7B;&quot;index&quot;: 2, &quot;type&quot;: &quot;object&quot;, &quot;dfid&quot;: &quot;Code&quot;&#x7D;, &quot;Daily hospital occupancy&quot;: &#x7B;&quot;index&quot;: 3, &quot;type&quot;: &quot;int&quot;, &quot;dfid&quot;: &quot;Daily hospital occupancy&quot;&#x7D;, &quot;Day_str&quot;: &#x7B;&quot;index&quot;: 0, &quot;type&quot;: &quot;datetime&quot;, &quot;dfid&quot;: &quot;Day&quot;, &quot;format&quot;: &quot;eee dd MMM yyyy&quot;&#x7D;}\"',          'height=\"80vh\"',          'width=\"100%\"',          'pageSizeOptions=\"[10, 30, 100]\"',          \"pageSize={10.0}\",          \"selected={[]}\",          'updateVarName=\"_TpD_tpec_TpExPr_csvdata_TPMDL_0\"',          \"data={_TpD_tpec_TpExPr_csvdata_TPMDL_0}\",          \"columns={tp_TpExPr_gui_tbl_cols_True_None_7B_22columns_22_3A_20_22Day_3BEntity_3BCode_3BDaily_20hospital_20occupancy_22_2C_20_22date_format_22_3A_20_22eee_20dd_20MMM_20yyyy_22_7D_7B_22data_22_3A_20_22tpec_TpExPr_csvdata_TPMDL_0_22_7D_tpec_TpExPr_csvdata_TPMDL_0_csvdata_TPMDL_0_0}\",      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_builder(gui, page, expected_list)      def test_table_builder_2(gui: Gui, helpers, csvdata):      table_properties = {  # noqa: F841          \"page_size\": 10,          \"page_size_options\": [10, 50, 100, 500],          \"allow_all_rows\": True,          \"columns\": {              \"Day\": {\"index\": 0, \"format\": \"dd/MM/yyyy\", \"title\": \"Date of measure\"},              \"Entity\": {\"index\": 1},              \"Code\": {\"index\": 2},              \"Daily hospital occupancy\": {\"index\": 3},          },          \"date_format\": \"eee dd MMM yyyy\",          \"number_format\": \"%.3f\",          \"width\": \"60vw\",          \"height\": \"60vh\",      }      with tgb.Page(frame=None) as page:          tgb.table(data=\"{csvdata}\", properties=\"table_properties\", auto_loading=True, editable=False)      expected_list = [          \"<Table\",          \"allowAllRows={true}\",          \"autoLoading={true}\",          \"editable={false}\",          'defaultColumns=\"{&quot;Entity&quot;: &#x7B;&quot;index&quot;: 1, &quot;type&quot;: &quot;object&quot;, &quot;dfid&quot;: &quot;Entity&quot;&#x7D;, &quot;Code&quot;: &#x7B;&quot;index&quot;: 2, &quot;type&quot;: &quot;object&quot;, &quot;dfid&quot;: &quot;Code&quot;&#x7D;, &quot;Daily hospital occupancy&quot;: &#x7B;&quot;index&quot;: 3, &quot;type&quot;: &quot;int&quot;, &quot;dfid&quot;: &quot;Daily hospital occupancy&quot;, &quot;format&quot;: &quot;%.3f&quot;&#x7D;, &quot;Day_str&quot;: &#x7B;&quot;index&quot;: 0, &quot;format&quot;: &quot;dd/MM/yyyy&quot;, &quot;title&quot;: &quot;Date of measure&quot;, &quot;type&quot;: &quot;datetime&quot;, &quot;dfid&quot;: &quot;Day&quot;&#x7D;}\"',          'height=\"60vh\"',          'width=\"60vw\"',          'pageSizeOptions=\"[10, 50, 100, 500]\"',          \"pageSize={10}\",          \"selected={[]}\",          'updateVarName=\"_TpD_tpec_TpExPr_csvdata_TPMDL_0\"',          \"data={_TpD_tpec_TpExPr_csvdata_TPMDL_0}\",      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import os  import pathlib  from importlib import util    import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_image_url_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", \"some_url\")      with tgb.Page(frame=None) as page:          tgb.image(content=\"{content}\")      expected_list = [          \"<Image\",          \"content={_TpCi_tpec_TpExPr_content_TPMDL_0}\",          'defaultContent=\"some_url\"',      ]      helpers.test_control_builder(gui, page, expected_list)      def test_image_file_builder(gui: Gui, test_client, helpers):      with open((pathlib.Path(__file__).parent.parent.parent / \"resources\" / \"fred.png\").resolve(), \"rb\") as content:          gui._bind_var_val(\"content\", content.read())          with tgb.Page(frame=None) as page:              tgb.image(content=\"{content}\")          expected_list = [              \"<Image\",              'defaultContent=\"data:image/png;base64,',          ]          if not util.find_spec(\"magic\"):              expected_list = [\"<Image\", 'defaultContent=\"/taipy-content/taipyStatic0/TaiPyContent.', \".bin\"]          helpers.test_control_builder(gui, page, expected_list)      def test_image_path_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"content\", str((pathlib.Path(__file__).parent.parent.parent / \"resources\" / \"fred.png\").resolve())      )      with tgb.Page(frame=None) as page:          tgb.image(content=\"{content}\")      expected_list = [          \"<Image\",          'defaultContent=\"/taipy-content/taipyStatic0/fred.png',      ]      helpers.test_control_builder(gui, page, expected_list)      def test_image_bad_file_builder(gui: Gui, test_client, helpers):      with open(os.path.abspath(__file__), \"rb\") as content:          gui._bind_var_val(\"content\", content.read())          with tgb.Page(frame=None) as page:              tgb.image(content=\"{content}\")          expected_list = [              \"<Image\",              'defaultContent=\"Invalid content: text/x',          ]          if not util.find_spec(\"magic\"):              expected_list = [\"<Image\", 'defaultContent=\"/taipy-content/taipyStatic0/TaiPyContent.', \".bin\"]          helpers.test_control_builder(gui, page, expected_list) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_html_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"name\", \"World!\")      gui._bind_var_val(\"btn_id\", \"button1\")      with tgb.Page(frame=None) as page:          tgb.html(\"h1\", \"This is a header\", style=\"color:Tomato;\")          with tgb.html(\"p\", \"This is a paragraph.\", style=\"color:green;\"):              tgb.html(\"a\", \"a text\", href=\"https://www.w3schools.com\", target=\"_blank\")              tgb.html(\"br\")              tgb.html(\"b\", \"This is bold text inside the paragrah.\")      expected_list = [          '<h1 style=\"color:Tomato;\">This is a header',          '<p style=\"color:green;\">This is a paragraph.',          '<a href=\"https://www.w3schools.com\" target=\"_blank\">a text',          \"<br>\",          \"<b>This is bold text inside the paragrah.\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import inspect    import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_status_builder(gui: Gui, helpers):      status = [{\"status\": \"info\", \"message\": \"Info Message\"}]  # noqa: F841      with tgb.Page(frame=None) as page:          tgb.status(value=\"{status}\")      expected_list = [          \"<Status\",          'defaultValue=\"[&#x7B;&quot;status&quot;: &quot;info&quot;, &quot;message&quot;: &quot;Info Message&quot;&#x7D;]\"',          \"value={tpec_TpExPr_status_TPMDL_0}\",      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_toggle_builder(gui: Gui, helpers):      with tgb.Page(frame=None) as page:          tgb.toggle(theme=True)      expected_list = [\"<Toggle\", 'kind=\"theme\"', 'unselectedValue=\"\"']      helpers.test_control_builder(gui, page, expected_list)      def test_toggle_allow_unselected_builder(gui: Gui, helpers):      with tgb.Page(frame=None) as page:          tgb.toggle(allow_unselect=True, lov=\"1;2\")      expected_list = [\"<Toggle\", 'unselectedValue=\"\"', \"allowUnselect={true}\"]      helpers.test_control_builder(gui, page, expected_list)      def test_toggle_lov_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"l1\")      gui._bind_var_val(\"lov\", [(\"l1\", \"v1\"), (\"l2\", \"v2\")])      with tgb.Page(frame=None) as page:          tgb.toggle(lov=\"{lov}\", value=\"{x}\", label=\"Label\")      expected_list = [          \"<Toggle\",          'defaultLov=\"[[&quot;l1&quot;, &quot;v1&quot;], [&quot;l2&quot;, &quot;v2&quot;]]\"',          'defaultValue=\"l1\"',          'label=\"Label\"',          \"lov={_TpL_tpec_TpExPr_lov_TPMDL_0}\",          'updateVars=\"lov=_TpL_tpec_TpExPr_lov_TPMDL_0\"',          'updateVarName=\"_TpLv_tpec_TpExPr_x_TPMDL_0\"',          'unselectedValue=\"\"',          \"value={_TpLv_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_pane_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"show_pane\", False)      with tgb.Page(frame=None) as page:          with tgb.pane(open=\"{show_pane}\"):              tgb.text(value=\"This is a Pane\")      expected_list = [          \"<Pane\",          'anchor=\"left\"',          'updateVarName=\"_TpB_tpec_TpExPr_show_pane_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_show_pane_TPMDL_0}\",          \"This is a Pane\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_pane_persistent_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"show_pane\", False)      with tgb.Page(frame=None) as page:          with tgb.pane(open=\"{show_pane}\", persistent=True):              tgb.text(value=\"This is a Pane\")      expected_list = [          \"<Pane\",          'anchor=\"left\"',          \"persistent={true}\",          'updateVarName=\"_TpB_tpec_TpExPr_show_pane_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_show_pane_TPMDL_0}\",          \"This is a Pane\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_text_builder_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      with tgb.Page(frame=None) as page:          tgb.text(value=\"{x}\")      expected_list = [\"<Field\", 'dataType=\"int\"', 'defaultValue=\"10\"', \"value={tpec_TpExPr_x_TPMDL_0}\"]      helpers.test_control_builder(gui, page, expected_list)      def test_text_builder_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      with tgb.Page(frame=None) as page:          tgb.text(\"{x}\")      expected_list = [\"<Field\", 'dataType=\"int\"', 'defaultValue=\"10\"', \"value={tpec_TpExPr_x_TPMDL_0}\"]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import os  import pathlib  from importlib import util    import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_file_download_url_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", \"some_url\")      with tgb.Page(frame=None) as page:          tgb.file_download(content=\"{content}\")      expected_list = [          \"<FileDownload\",          \"content={_TpC_tpec_TpExPr_content_TPMDL_0}\",          'defaultContent=\"some_url\"',      ]      helpers.test_control_builder(gui, page, expected_list)      def test_file_download_file_builder(gui: Gui, test_client, helpers):      with open((pathlib.Path(__file__).parent.parent.parent / \"resources\" / \"fred.png\").resolve(), \"rb\") as content:          gui._bind_var_val(\"content\", content.read())          with tgb.Page(frame=None) as page:              tgb.file_download(content=\"{content}\")          expected_list = [              \"<FileDownload\",              'defaultContent=\"data:image/png;base64,',          ]          if not util.find_spec(\"magic\"):              expected_list = [\"<FileDownload\", 'defaultContent=\"/taipy-content/taipyStatic0/TaiPyContent.', \".bin\"]          helpers.test_control_builder(gui, page, expected_list)      def test_file_download_path_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"content\", str((pathlib.Path(__file__).parent.parent.parent / \"resources\" / \"fred.png\").resolve())      )      with tgb.Page(frame=None) as page:          tgb.file_download(content=\"{content}\")      expected_list = [          \"<FileDownload\",          'defaultContent=\"/taipy-content/taipyStatic0/fred.png',      ]      helpers.test_control_builder(gui, page, expected_list)      def test_file_download_any_file_builder(gui: Gui, test_client, helpers):      with open(os.path.abspath(__file__), \"rb\") as content:          gui._bind_var_val(\"content\", content.read())          with tgb.Page(frame=None) as page:              tgb.file_download(content=\"{content}\")          expected_list = [              \"<FileDownload\",              'defaultContent=\"data:text/x',              \"python;base64,\",          ]          if not util.find_spec(\"magic\"):              expected_list = [\"<FileDownload\", 'defaultContent=\"/taipy-content/taipyStatic0/TaiPyContent.', \".bin\"]          helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_file_selector_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", None)      with tgb.Page(frame=None) as page:          tgb.file_selector(content=\"{content}\", label=\"label\", on_action=\"action\")      expected_list = [          \"<FileSelector\",          'updateVarName=\"tpec_TpExPr_content_TPMDL_0\"',          'label=\"label\"',          'onAction=\"action\"',      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import inspect    import taipy.gui.builder as tgb  from taipy.gui import Gui, Markdown      def test_dialog_builder_1(gui: Gui, helpers):      dialog_open = False  # noqa: F841      gui._set_frame(inspect.currentframe())      with tgb.Page(frame=None) as page:          tgb.dialog(title=\"This is a Dialog\", open=\"{dialog_open}\", page=\"page_test\", on_action=\"validate_action\")      expected_list = [          \"<Dialog\",          'onAction=\"validate_action\"',          'page=\"page_test\"',          'title=\"This is a Dialog\"',          'updateVarName=\"_TpB_tpec_TpExPr_dialog_open_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_dialog_open_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_dialog_builder_2(gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      partial = gui.add_partial(Markdown(\"# A partial\"))  # noqa: F841      dialog_open = False  # noqa: F841      with tgb.Page(frame=None) as page:          tgb.dialog(              title=\"Another Dialog\",              open=\"{dialog_open}\",              partial=\"{partial}\",              on_action=\"validate_action\",          )      expected_list = [          \"<Dialog\",          'page=\"TaiPy_partials',          'title=\"Another Dialog\"',          'onAction=\"validate_action\"',          'updateVarName=\"_TpB_tpec_TpExPr_dialog_open_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_dialog_open_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_dialog_labels_builder(gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      dialog_open = False  # noqa: F841      with tgb.Page(frame=None) as page:          tgb.dialog(              title=\"Another Dialog\",              open=\"{dialog_open}\",              page=\"page_test\",              labels=[\"Cancel\", \"Validate\"],              close_label=\"MYClose\",          )      expected_list = [          \"<Dialog\",          'page=\"page_test\"',          'title=\"Another Dialog\"',          'labels=\"[&quot;Cancel&quot;, &quot;Validate&quot;]\"',          'updateVarName=\"_TpB_tpec_TpExPr_dialog_open_TPMDL_0\"',          'closeLabel=\"MYClose\"',          \"open={_TpB_tpec_TpExPr_dialog_open_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_menu_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"lov\", [\"Item 1\", \"Item 2\", \"Item 3\", \"Item 4\"])      with tgb.Page(frame=None) as page:          tgb.menu(lov=\"{lov}\", on_action=\"on_menu_action\")      expected_list = [          \"<MenuCtl\",          'libClassName=\"taipy-menu\"',          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;, &quot;Item 4&quot;]\"',          \"lov={_TpL_tpec_TpExPr_lov_TPMDL_0}\",          'onAction=\"on_menu_action\"',          'updateVars=\"lov=_TpL_tpec_TpExPr_lov_TPMDL_0\"',      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_layout_builder_1(gui: Gui, helpers):      with tgb.Page(frame=None) as page:          with tgb.layout(columns=\"1 1\", gap=\"1rem\"):              tgb.text(value=\"This is a layout section\")      expected_list = [\"<Layout\", 'columns=\"1 1', 'gap=\"1rem\"', \"This is a layout section\"]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_number_builder_1(gui: Gui, helpers):      with tgb.Page(frame=None) as page:          tgb.number(value=\"10\")      expected_list = [\"<Input\", 'value=\"10\"', 'type=\"number\"']      helpers.test_control_builder(gui, page, expected_list)      def test_number_builder_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"10\")      with tgb.Page(frame=None) as page:          tgb.number(value=\"{x}\")      expected_list = [          \"<Input\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"10\"',          'type=\"number\"',          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "from datetime import datetime    import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_date_builder_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"date\", datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"))      with tgb.Page(frame=None) as page:          tgb.date(id=\"date\", date=\"{date}\")      expected_list = [          \"<DateSelector\",          'defaultDate=\"2020-12-',          'updateVarName=\"_TpDt_tpec_TpExPr_date_TPMDL_0\"',          \"date={_TpDt_tpec_TpExPr_date_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_date_builder_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"date\", datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"))      with tgb.Page(frame=None) as page:          tgb.date(id=\"date\", date=\"{date}\", with_time=True)      expected_list = [          \"<DateSelector\",          'defaultDate=\"2020-12-',          'updateVarName=\"_TpDt_tpec_TpExPr_date_TPMDL_0\"',          \"date={_TpDt_tpec_TpExPr_date_TPMDL_0}\",          \"withTime={true}\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_indicator_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"val\", 15)      with tgb.Page(frame=None) as page:          tgb.indicator(display=12, value=\"{val}\", min=1, max=20, format=\"%.2f\")      expected_list = [          \"<Indicator\",          'libClassName=\"taipy-indicator\"',          \"defaultValue={15}\",          \"display={12.0}\",          'format=\"%.2f\"',          \"max={20.0}\",          \"min={1.0}\",          \"value={_TpN_tpec_TpExPr_val_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_navbar_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"navlov\",          [              (\"/page1\", \"Page 1\"),              (\"/page2\", \"Page 2\"),              (\"/page3\", \"Page 3\"),              (\"/page4\", \"Page 4\"),          ],      )      with tgb.Page(frame=None) as page:          tgb.navbar(lov=\"{navlov}\")      expected_list = [          \"<NavBar\",          'defaultLov=\"[[&quot;/page1&quot;, &quot;Page 1&quot;], [&quot;/page2&quot;, &quot;Page 2&quot;], [&quot;/page3&quot;, &quot;Page 3&quot;], [&quot;/page4&quot;, &quot;Page 4&quot;]]\"',          \"lov={_TpL_tpec_TpExPr_navlov_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_part_builder_1(gui: Gui, helpers):      with tgb.Page(frame=None) as page:          with tgb.part(class_name=\"class1\"):              tgb.text(value=\"This is a part\")      expected_list = [\"<Part\", \"This is a part\"]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import inspect    from taipy.gui import Gui      def test_slider_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      md_string = \"<|{x}|slider|>\"      expected_list = [          \"<Slider\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0',          \"defaultValue={10}\",          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_slider_with_min_max(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 0)      md_string = \"<|{x}|slider|min=-10|max=10|>\"      expected_list = [\"<Slider\", \"min={-10.0}\", \"max={10.0}\", \"defaultValue={0}\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_slider_with_dict_labels_md(gui: Gui, helpers):      sel = \"Item 1\"  # noqa: F841      labels = {\"Item 1\": \"Label Start\", \"Item 3\": \"Label End\"}  # noqa: F841      gui._set_frame(inspect.currentframe())      md_string = \"<|{sel}|slider|lov=Item 1;Item 2;Item 3|labels={labels}|>\"      expected_list = [          \"<Slider\",          'labels=\"{&quot;Item 1&quot;: &quot;Label Start&quot;, &quot;Item 3&quot;: &quot;Label End&quot;}\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_slider_with_boolean_labels_md(gui: Gui, helpers):      sel = \"Item 1\"  # noqa: F841      gui._set_frame(inspect.currentframe())      md_string = \"<|{sel}|slider|lov=Item 1;Item 2;Item 3|labels|>\"      expected_list = [\"<Slider\", \"labels={true}\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_slider_items_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"Item 1\")      md_string = \"<|{x}|slider|lov=Item 1;Item 2;Item 3|text_anchor=left|>\"      expected_list = [          \"<Slider\",          'updateVarName=\"_TpLv_tpec_TpExPr_x_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_x_TPMDL_0}\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'textAnchor=\"left\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_slider_text_anchor_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"Item 1\")      md_string = \"<|{x}|slider|text_anchor=NoNe|>\"      expected_list = [          \"<Slider\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",          'textAnchor=\"none\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_slider_text_anchor_default_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"Item 1\")      md_string = \"<|{x}|slider|items=Item 1|>\"      expected_list = [          \"<Slider\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",          'textAnchor=\"bottom\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_slider_array_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", [10, 20])      md_string = \"<|{x}|slider|>\"      expected_list = [          \"<Slider\",          'updateVarName=\"_TpLn_tpec_TpExPr_x_TPMDL_0\"',          \"value={_TpLn_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_slider_html_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      html_string = '<taipy:slider value=\"{x}\" />'      expected_list = [          \"<Slider\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          \"defaultValue={10}\",          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_slider_html_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      html_string = \"<taipy:slider>{x}</taipy:slider>\"      expected_list = [          \"<Slider\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          \"defaultValue={10}\",          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from taipy.gui import Gui      def test_button_md_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"name\", \"World!\")      gui._bind_var_val(\"btn_id\", \"button1\")      md_string = \"<|Hello {name}|button|id={btn_id}|>\"      expected_list = [\"<Button\", 'defaultLabel=\"Hello World!\"', \"label={tp_TpExPr_Hello_name_TPMDL_0_0\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_button_md_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"name\", \"World!\")      gui._bind_var_val(\"btn_id\", \"button1\")      md_string = \"<|button|label=Hello {name}|id={btn_id}|>\"      expected_list = [\"<Button\", 'defaultLabel=\"Hello World!\"', \"label={tp_TpExPr_Hello_name_TPMDL_0_0\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_button_html_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"name\", \"World!\")      gui._bind_var_val(\"btn_id\", \"button1\")      html_string = '<taipy:button label=\"Hello {name}\" id=\"{btn_id}\" />'      expected_list = [\"<Button\", 'defaultLabel=\"Hello World!\"', \"label={tp_TpExPr_Hello_name_TPMDL_0_0\"]      helpers.test_control_html(gui, html_string, expected_list)      def test_button_html_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"name\", \"World!\")      gui._bind_var_val(\"btn_id\", \"button1\")      html_string = '<taipy:button id=\"{btn_id}\">Hello {name}</taipy:button>'      expected_list = [\"<Button\", 'defaultLabel=\"Hello World!\"', \"label={tp_TpExPr_Hello_name_TPMDL_0_0\"]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_selector_md_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"selected_val\", [\"l1\", \"l2\"])      gui._bind_var_val(\"selector_properties\", {\"lov\": [(\"l1\", \"v1\"), (\"l2\", \"v2\"), (\"l3\", \"v3\")], \"filter\": True})      md_string = \"<|{selected_val}|selector|properties=selector_properties|multiple|>\"      expected_list = [          \"<Selector\",          'defaultLov=\"[[&quot;l1&quot;, &quot;v1&quot;], [&quot;l2&quot;, &quot;v2&quot;], [&quot;l3&quot;, &quot;v3&quot;]]\"',          'defaultValue=\"[&quot;l1&quot;, &quot;l2&quot;]\"',          \"filter={true}\",          \"multiple={true}\",          'updateVarName=\"_TpLv_tpec_TpExPr_selected_val_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_val_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_selector_md_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"selected_val\", \"Item 2\")      md_string = \"<|{selected_val}|selector|lov=Item 1;Item 2; This is a another value|>\"      expected_list = [          \"<Selector\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot; This is a another value&quot;]\"',          'defaultValue=\"[&quot;Item 2&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_selected_val_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_val_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_selector_md_3(gui: Gui, test_client, helpers):      gui._bind_var_val(\"elt\", None)      gui._bind_var_val(          \"scenario_list\",          [{\"id\": \"1\", \"name\": \"scenario 1\"}, {\"id\": \"3\", \"name\": \"scenario 3\"}, {\"id\": \"2\", \"name\": \"scenario 2\"}],      )      gui._bind_var_val(\"selected_obj\", {\"id\": \"1\", \"name\": \"scenario 1\"})      md_string = '<|{selected_obj}|selector|lov={scenario_list}|type=Scenario|adapter={lambda elt: (elt[\"id\"], elt[\"name\"])}|not propagate|>'      expected_list = [          \"<Selector\",          'defaultLov=\"[[&quot;1&quot;, &quot;scenario 1&quot;], [&quot;3&quot;, &quot;scenario 3&quot;], [&quot;2&quot;, &quot;scenario 2&quot;]]\"',          'defaultValue=\"[&quot;1&quot;]\"',          \"lov={_TpL_tpec_TpExPr_scenario_list_TPMDL_0}\",          \"propagate={false}\",          'updateVars=\"lov=_TpL_tpec_TpExPr_scenario_list_TPMDL_0\"',          'updateVarName=\"_TpLv_tpec_TpExPr_selected_obj_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_obj_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_selector_html_1_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"selected_val\", [\"l1\", \"l2\"])      gui._bind_var_val(\"selector_properties\", {\"lov\": [(\"l1\", \"v1\"), (\"l2\", \"v2\"), (\"l3\", \"v3\")], \"filter\": True})      html_string = '<taipy:selector value=\"{selected_val}\" properties=\"selector_properties\" multiple=\"True\"/>'      expected_list = [          \"<Selector\",          'defaultLov=\"[[&quot;l1&quot;, &quot;v1&quot;], [&quot;l2&quot;, &quot;v2&quot;], [&quot;l3&quot;, &quot;v3&quot;]]\"',          'defaultValue=\"[&quot;l1&quot;, &quot;l2&quot;]\"',          \"filter={true}\",          \"multiple={true}\",          'updateVarName=\"_TpLv_tpec_TpExPr_selected_val_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_val_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_selector_html_1_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"selected_val\", [\"l1\", \"l2\"])      gui._bind_var_val(\"selector_properties\", {\"lov\": [(\"l1\", \"v1\"), (\"l2\", \"v2\"), (\"l3\", \"v3\")], \"filter\": True})      html_string = '<taipy:selector properties=\"selector_properties\" multiple=\"True\">{selected_val}</taipy:selector>'      expected_list = [          \"<Selector\",          'defaultLov=\"[[&quot;l1&quot;, &quot;v1&quot;], [&quot;l2&quot;, &quot;v2&quot;], [&quot;l3&quot;, &quot;v3&quot;]]\"',          'defaultValue=\"[&quot;l1&quot;, &quot;l2&quot;]\"',          \"filter={true}\",          \"multiple={true}\",          'updateVarName=\"_TpLv_tpec_TpExPr_selected_val_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_val_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_selector_html_2_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"selected_val\", \"Item 2\")      html_string = '<taipy:selector value=\"{selected_val}\" lov=\"Item 1;Item 2; This is a another value\" />'      expected_list = [          \"<Selector\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot; This is a another value&quot;]\"',          'defaultValue=\"[&quot;Item 2&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_selected_val_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_val_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_selector_html_2_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"selected_val\", \"Item 2\")      html_string = '<taipy:selector lov=\"Item 1;Item 2; This is a another value\">{selected_val}</taipy:selector>'      expected_list = [          \"<Selector\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot; This is a another value&quot;]\"',          'defaultValue=\"[&quot;Item 2&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_selected_val_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_val_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "import inspect    from taipy.gui import Gui      def test_input_md(gui: Gui, helpers):      x = \"Hello World!\"  # noqa: F841      gui._set_frame(inspect.currentframe())      md_string = \"<|{x}|input|>\"      expected_list = [          \"<Input\",          'updateVarName=\"tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"Hello World!\"',          'type=\"text\"',          \"value={tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_password_md(gui: Gui, helpers):      x = \"Hello World!\"  # noqa: F841      gui._set_frame(inspect.currentframe())      md_string = \"<|{x}|input|password|>\"      expected_list = [          \"<Input\",          'updateVarName=\"tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"Hello World!\"',          'type=\"password\"',          \"value={tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_input_html_1(gui: Gui, helpers):      x = \"Hello World!\"  # noqa: F841      gui._set_frame(inspect.currentframe())      html_string = '<taipy:input value=\"{x}\" />'      expected_list = [          \"<Input\",          'updateVarName=\"tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"Hello World!\"',          'type=\"text\"',          \"value={tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_password_html(gui: Gui, helpers):      x = \"Hello World!\"  # noqa: F841      gui._set_frame(inspect.currentframe())      html_string = '<taipy:input value=\"{x}\" password=\"True\" />'      expected_list = [          \"<Input\",          'updateVarName=\"tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"Hello World!\"',          'type=\"password\"',          \"value={tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_input_html_2(gui: Gui, helpers):      x = \"Hello World!\"  # noqa: F841      gui._set_frame(inspect.currentframe())      html_string = \"<taipy:input>{x}</taipy:input>\"      expected_list = [          \"<Input\",          'updateVarName=\"tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"Hello World!\"',          'type=\"text\"',          \"value={tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_tree_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"value\", \"Item 1\")      md_string = \"<|{value}|tree|lov=Item 1;Item 2;Item 3|>\"      expected_list = [          \"<TreeView\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_value_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_value_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_tree_expanded_md_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"value\", \"Item 1\")      md_string = \"<|{value}|tree|lov=Item 1;Item 2;Item 3|not expanded|>\"      expected_list = [          \"<TreeView\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_value_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_value_TPMDL_0}\",          \"expanded={false}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_tree_expanded_md_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"value\", \"Item 1\")      gui._bind_var_val(\"expa\", [\"Item1\"])      md_string = \"<|{value}|tree|lov=Item 1;Item 2;Item 3|expanded={expa}|>\"      expected_list = [          \"<TreeView\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_value_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_value_TPMDL_0}\",          'defaultExpanded=\"[&quot;Item1&quot;]\"',          \"expanded={tpec_TpExPr_expa_TPMDL_0}\",          'updateVars=\"expanded=tpec_TpExPr_expa_TPMDL_0',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_tree_html_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"value\", \"Item 1\")      html_string = '<taipy:tree lov=\"Item 1;Item 2;Item 3\">{value}</taipy:tree>'      expected_list = [          \"<TreeView\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_value_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_value_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_tree_html_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"value\", \"Item 1\")      html_string = '<taipy:tree lov=\"Item 1;Item 2;Item 3\" value=\"{value}\" />'      expected_list = [          \"<TreeView\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_value_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_value_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_expandable_md_1(gui: Gui, helpers):      md_string = \"\"\"  <|Expandable section|expandable|not expanded|  # This is an expandable section  |>  \"\"\"      expected_list = [          \"<Expandable\",          \"expanded={false}\",          'title=\"Expandable section\"',          \"<h1\",          \"This is an expandable section\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_expandable_md_2(gui: Gui, helpers):      md_string = \"\"\"  <|expandable.start|title=Expandable section|not expanded|>  # This is an expandable section  <|expandable.end|>  \"\"\"      expected_list = [          \"<Expandable\",          \"expanded={false}\",          'title=\"Expandable section\"',          \"<h1\",          \"This is an expandable section\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_expandable_html(gui: Gui, helpers):      html_string = '<taipy:expandable title=\"Expandable section\" expanded=\"false\"><h1>This is an expandable section</h1></taipy:expandable >'      expected_list = [          \"<Expandable\",          \"expanded={false}\",          'title=\"Expandable section\"',          \"<h1\",          \"This is an expandable section\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from datetime import datetime    from taipy.gui import Gui      def test_date_range_md_1(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"dates\", [datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"), datetime.strptime(\"31 Dec 2020\", \"%d %b %Y\")]      )      md_string = \"<|{dates}|date_range|>\"      expected_list = [          \"<DateRange\",          'defaultDates=\"[&quot;2020-12-',          'updateVarName=\"_TpDr_tpec_TpExPr_dates_TPMDL_0\"',          \"dates={_TpDr_tpec_TpExPr_dates_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_date_range_md_2(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"dates\", [datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"), datetime.strptime(\"31 Dec 2020\", \"%d %b %Y\")]      )      md_string = \"<|{dates}|date_range|with_time|label_start=start|label_end=end|>\"      expected_list = [          \"<DateRange\",          'defaultDates=\"[&quot;2020-12-',          'updateVarName=\"_TpDr_tpec_TpExPr_dates_TPMDL_0\"',          \"dates={_TpDr_tpec_TpExPr_dates_TPMDL_0}\",          \"withTime={true}\",          'labelStart=\"start\"',          'labelEnd=\"end\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_date_range_html_1(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"dates\", [datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"), datetime.strptime(\"31 Dec 2020\", \"%d %b %Y\")]      )      html_string = '<taipy:date_range dates=\"{dates}\" />'      expected_list = [          \"<DateRange\",          'defaultDates=\"[&quot;2020-12-',          'updateVarName=\"_TpDr_tpec_TpExPr_dates_TPMDL_0\"',          \"dates={_TpDr_tpec_TpExPr_dates_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_date_range_html_2(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"dates\", [datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"), datetime.strptime(\"31 Dec 2020\", \"%d %b %Y\")]      )      html_string = \"<taipy:date_range>{dates}</taipy:date_range>\"      expected_list = [          \"<DateRange\",          'defaultDates=\"[&quot;2020-12-',          'updateVarName=\"_TpDr_tpec_TpExPr_dates_TPMDL_0\"',          \"dates={_TpDr_tpec_TpExPr_dates_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "import os  import pathlib  from importlib import util    from taipy.gui import Gui      def test_image_url_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", \"some_url\")      md_string = \"<|{content}|image|>\"      expected_list = [          \"<Image\",          \"content={_TpCi_tpec_TpExPr_content_TPMDL_0}\",          'defaultContent=\"some_url\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_image_file_md(gui: Gui, test_client, helpers):      with open((pathlib.Path(__file__).parent.parent / \"resources\" / \"fred.png\").resolve(), \"rb\") as content:          gui._bind_var_val(\"content\", content.read())          md_string = \"<|{content}|image|>\"          expected_list = [              \"<Image\",              'defaultContent=\"data:image/png;base64,',          ]          if not util.find_spec(\"magic\"):              expected_list = [\"<Image\", 'defaultContent=\"/taipy-content/taipyStatic0/TaiPyContent.', \".bin\"]          helpers.test_control_md(gui, md_string, expected_list)      def test_image_path_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", str((pathlib.Path(__file__).parent.parent / \"resources\" / \"fred.png\").resolve()))      md_string = \"<|{content}|image|>\"      expected_list = [          \"<Image\",          'defaultContent=\"/taipy-content/taipyStatic0/fred.png',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_image_bad_file_md(gui: Gui, test_client, helpers):      with open(os.path.abspath(__file__), \"rb\") as content:          gui._bind_var_val(\"content\", content.read())          md_string = \"<|{content}|image|>\"          expected_list = [              \"<Image\",              'defaultContent=\"Invalid content: text/x',          ]          if not util.find_spec(\"magic\"):              expected_list = [\"<Image\", 'defaultContent=\"/taipy-content/taipyStatic0/TaiPyContent.', \".bin\"]          helpers.test_control_md(gui, md_string, expected_list)      def test_image_url_html(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", \"some_url\")      html_string = '<taipy:image content=\"{content}\" on_action=\"action\" />'      expected_list = [          \"<Image\",          'defaultContent=\"some_url\"',          'onAction=\"action\"',      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import inspect    from taipy.gui import Gui      def test_status_md(gui: Gui, helpers):      status = [{\"status\": \"info\", \"message\": \"Info Message\"}]  # noqa: F841      md_string = \"<|{status}|status|>\"      expected_list = [          \"<Status\",          'defaultValue=\"[&#x7B;&quot;status&quot;: &quot;info&quot;, &quot;message&quot;: &quot;Info Message&quot;&#x7D;]\"',          \"value={tpec_TpExPr_status_TPMDL_0}\",      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_md(gui, md_string, expected_list)      def test_status_html(gui: Gui, helpers):      status = [{\"status\": \"info\", \"message\": \"Info Message\"}]  # noqa: F841      html_string = '<taipy:status value=\"{status}\" />'      expected_list = [          \"<Status\",          'defaultValue=\"[&#x7B;&quot;status&quot;: &quot;info&quot;, &quot;message&quot;: &quot;Info Message&quot;&#x7D;]\"',          \"value={tpec_TpExPr_status_TPMDL_0}\",      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_toggle_md(gui: Gui, helpers):      md_string = \"<|toggle|theme|>\"      expected_list = [\"<Toggle\", 'kind=\"theme\"', 'unselectedValue=\"\"']      helpers.test_control_md(gui, md_string, expected_list)      def test_toggle_allow_unselected_md(gui: Gui, helpers):      md_string = \"<|toggle|lov=1;2|allow_unselect|>\"      expected_list = [\"<Toggle\", 'unselectedValue=\"\"', \"allowUnselect={true}\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_toggle_lov_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"l1\")      gui._bind_var_val(\"lov\", [(\"l1\", \"v1\"), (\"l2\", \"v2\")])      md_string = \"<|{x}|toggle|lov={lov}|label=Label|>\"      expected_list = [          \"<Toggle\",          'defaultLov=\"[[&quot;l1&quot;, &quot;v1&quot;], [&quot;l2&quot;, &quot;v2&quot;]]\"',          'defaultValue=\"l1\"',          'label=\"Label\"',          \"lov={_TpL_tpec_TpExPr_lov_TPMDL_0}\",          'updateVars=\"lov=_TpL_tpec_TpExPr_lov_TPMDL_0\"',          'updateVarName=\"_TpLv_tpec_TpExPr_x_TPMDL_0\"',          'unselectedValue=\"\"',          \"value={_TpLv_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_toggle_html_1(gui: Gui, helpers):      html_string = '<taipy:toggle theme=\"True\" />'      expected_list = [\"<Toggle\", 'kind=\"theme\"', 'unselectedValue=\"\"']      helpers.test_control_html(gui, html_string, expected_list)      def test_toggle_html_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"l1\")      gui._bind_var_val(\"lov\", [(\"l1\", \"v1\"), (\"l2\", \"v2\")])      html_string = '<taipy:toggle lov=\"{lov}\" label=\"Label\">{x}</taipy:toggle>'      expected_list = [          \"<Toggle\",          'defaultLov=\"[[&quot;l1&quot;, &quot;v1&quot;], [&quot;l2&quot;, &quot;v2&quot;]]\"',          'defaultValue=\"l1\"',          'label=\"Label\"',          \"lov={_TpL_tpec_TpExPr_lov_TPMDL_0}\",          'updateVars=\"lov=_TpL_tpec_TpExPr_lov_TPMDL_0\"',          'updateVarName=\"_TpLv_tpec_TpExPr_x_TPMDL_0\"',          'unselectedValue=\"\"',          \"value={_TpLv_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_pane_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"show_pane\", False)      md_string = \"\"\"  <|{show_pane}|pane|not persistent|  # This is a Pane  |>  \"\"\"      expected_list = [          \"<Pane\",          'anchor=\"left\"',          'updateVarName=\"_TpB_tpec_TpExPr_show_pane_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_show_pane_TPMDL_0}\",          \"<h1\",          \"This is a Pane</h1></Pane>\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_pane_persistent_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"show_pane\", False)      md_string = \"\"\"  <|{show_pane}|pane|persistent|  # This is a Pane  |>  \"\"\"      expected_list = [          \"<Pane\",          'anchor=\"left\"',          \"persistent={true}\",          'updateVarName=\"_TpB_tpec_TpExPr_show_pane_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_show_pane_TPMDL_0}\",          \"<h1\",          \"This is a Pane</h1></Pane>\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_pane_html(gui: Gui, test_client, helpers):      gui._bind_var_val(\"show_pane\", False)      html_string = '<taipy:pane open=\"{show_pane}\" persistent=\"false\"><h1>This is a Pane</h1></taipy:pane>'      expected_list = [          \"<Pane\",          'anchor=\"left\"',          'updateVarName=\"_TpB_tpec_TpExPr_show_pane_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_show_pane_TPMDL_0}\",          \"<h1\",          \"This is a Pane</h1></Pane>\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_text_md_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      md_string = \"<|{x}|>\"      expected_list = [\"<Field\", 'dataType=\"int\"', 'defaultValue=\"10\"', \"value={tpec_TpExPr_x_TPMDL_0}\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_text_html_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      html_string = '<taipy:text value=\"{x}\" />'      expected_list = [\"<Field\", 'dataType=\"int\"', 'defaultValue=\"10\"', \"value={tpec_TpExPr_x_TPMDL_0}\"]      helpers.test_control_html(gui, html_string, expected_list)      def test_text_html_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      html_string = \"<taipy:text>{x}</taipy:text>\"      expected_list = [\"<Field\", 'dataType=\"int\"', 'defaultValue=\"10\"', \"value={tpec_TpExPr_x_TPMDL_0}\"]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "import os  import pathlib  from importlib import util    from taipy.gui import Gui      def test_file_download_url_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", \"some_url\")      md_string = \"<|{content}|file_download|>\"      expected_list = [          \"<FileDownload\",          \"content={_TpC_tpec_TpExPr_content_TPMDL_0}\",          'defaultContent=\"some_url\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_file_download_file_md(gui: Gui, test_client, helpers):      with open((pathlib.Path(__file__).parent.parent / \"resources\" / \"fred.png\").resolve(), \"rb\") as content:          gui._bind_var_val(\"content\", content.read())          md_string = \"<|{content}|file_download|>\"          expected_list = [              \"<FileDownload\",              'defaultContent=\"data:image/png;base64,',          ]          if not util.find_spec(\"magic\"):              expected_list = [\"<FileDownload\", 'defaultContent=\"/taipy-content/taipyStatic0/TaiPyContent.', \".bin\"]          helpers.test_control_md(gui, md_string, expected_list)      def test_file_download_path_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", str((pathlib.Path(__file__).parent.parent / \"resources\" / \"fred.png\").resolve()))      md_string = \"<|{content}|file_download|>\"      expected_list = [          \"<FileDownload\",          'defaultContent=\"/taipy-content/taipyStatic0/fred.png',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_file_download_any_file_md(gui: Gui, test_client, helpers):      with open(os.path.abspath(__file__), \"rb\") as content:          gui._bind_var_val(\"content\", content.read())          md_string = \"<|{content}|file_download|>\"          expected_list = [              \"<FileDownload\",              'defaultContent=\"data:text/x',              \"python;base64,\",          ]          if not util.find_spec(\"magic\"):              expected_list = [\"<FileDownload\", 'defaultContent=\"/taipy-content/taipyStatic0/TaiPyContent.', \".bin\"]          helpers.test_control_md(gui, md_string, expected_list)      def test_file_download_url_html(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", \"some_url\")      html_string = '<taipy:file_download content=\"{content}\" />'      expected_list = [          \"<FileDownload\",          'defaultContent=\"some_url\"',      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_file_selector_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", None)      md_string = \"<|{content}|file_selector|label=label|on_action=action|>\"      expected_list = [          \"<FileSelector\",          'updateVarName=\"tpec_TpExPr_content_TPMDL_0\"',          'label=\"label\"',          'onAction=\"action\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_file_selector_html(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", None)      html_string = '<taipy:file_selector content=\"{content}\" label=\"label\" on_action=\"action\" />'      expected_list = [          \"<FileSelector\",          'updateVarName=\"tpec_TpExPr_content_TPMDL_0\"',          'label=\"label\"',          'onAction=\"action\"',      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_content_md(gui: Gui, helpers):      md_string = \"<|content|>\"      expected_list = [\"<PageContent\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_content_html(gui: Gui, helpers):      html_string = \"<taipy:content />\"      expected_list = [\"<PageContent\"]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "import inspect    from taipy.gui import Gui, Markdown      def test_dialog_md_1(gui: Gui, helpers):      dialog_open = False  # noqa: F841      gui._set_frame(inspect.currentframe())      md_string = \"<|dialog|title=This is a Dialog|open={dialog_open}|page=page_test|on_action=validate_action|>\"      expected_list = [          \"<Dialog\",          'onAction=\"validate_action\"',          'page=\"page_test\"',          'title=\"This is a Dialog\"',          'updateVarName=\"_TpB_tpec_TpExPr_dialog_open_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_dialog_open_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_dialog_md_2(gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      partial = gui.add_partial(Markdown(\"# A partial\"))  # noqa: F841      dialog_open = False  # noqa: F841      md_string = \"<|dialog|title=Another Dialog|open={dialog_open}|partial={partial}|on_action=validate_action|>\"      expected_list = [          \"<Dialog\",          'page=\"TaiPy_partials',          'title=\"Another Dialog\"',          'onAction=\"validate_action\"',          'updateVarName=\"_TpB_tpec_TpExPr_dialog_open_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_dialog_open_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_dialog_labels_md(gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      dialog_open = False  # noqa: F841      md_string = (          \"<|dialog|title=Another Dialog|open={dialog_open}|page=page_test|labels=Cancel;Validate|close_label=MYClose|>\"      )      expected_list = [          \"<Dialog\",          'page=\"page_test\"',          'title=\"Another Dialog\"',          'labels=\"[&quot;Cancel&quot;, &quot;Validate&quot;]\"',          'updateVarName=\"_TpB_tpec_TpExPr_dialog_open_TPMDL_0\"',          'closeLabel=\"MYClose\"',          \"open={_TpB_tpec_TpExPr_dialog_open_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_dialog_html_1(gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      dialog_open = False  # noqa: F841      html_string = (          '<taipy:dialog title=\"This is a Dialog\" open=\"{dialog_open}\" page=\"page1\" on_action=\"validate_action\" />'      )      expected_list = [          \"<Dialog\",          'page=\"page1\"',          'title=\"This is a Dialog\"',          'onAction=\"validate_action\"',          'updateVarName=\"_TpB_tpec_TpExPr_dialog_open_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_dialog_open_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_dialog_html_2(gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      partial = gui.add_partial(Markdown(\"# A partial\"))  # noqa: F841      dialog_open = False  # noqa: F841      html_string = (          '<taipy:dialog title=\"Another Dialog\" open=\"{dialog_open}\" partial=\"{partial}\" on_action=\"validate_action\" />'      )      expected_list = [          \"<Dialog\",          'page=\"TaiPy_partials',          'title=\"Another Dialog\"',          'onAction=\"validate_action\"',          'updateVarName=\"_TpB_tpec_TpExPr_dialog_open_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_dialog_open_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_dialog_labels_html(gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      dialog_open = False  # noqa: F841      html_string = (          '<taipy:dialog title=\"Another Dialog\" open=\"{dialog_open}\" page=\"page_test\" labels=\"Cancel;Validate\" />'      )      expected_list = [          \"<Dialog\",          'page=\"page_test\"',          'title=\"Another Dialog\"',          'labels=\"[&quot;Cancel&quot;, &quot;Validate&quot;]\"',          'updateVarName=\"_TpB_tpec_TpExPr_dialog_open_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_dialog_open_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_menu_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"lov\", [\"Item 1\", \"Item 2\", \"Item 3\", \"Item 4\"])      md_string = \"<|menu|lov={lov}|on_action=on_menu_action|>\"      expected_list = [          \"<MenuCtl\",          'libClassName=\"taipy-menu\"',          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;, &quot;Item 4&quot;]\"',          \"lov={_TpL_tpec_TpExPr_lov_TPMDL_0}\",          'onAction=\"on_menu_action\"',          'updateVars=\"lov=_TpL_tpec_TpExPr_lov_TPMDL_0\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_menu_html(gui: Gui, test_client, helpers):      gui._bind_var_val(\"lov\", [\"Item 1\", \"Item 2\", \"Item 3\", \"Item 4\"])      html_string = '<taipy:menu lov=\"{lov}\" />'      expected_list = [          \"<MenuCtl\",          'libClassName=\"taipy-menu\"',          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;, &quot;Item 4&quot;]\"',          \"lov={_TpL_tpec_TpExPr_lov_TPMDL_0}\",          'updateVars=\"lov=_TpL_tpec_TpExPr_lov_TPMDL_0\"',      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_layout_md_1(gui: Gui, helpers):      md_string = \"\"\"  <|layout|columns=1 1|gap=1rem|  # This is a layout section  |>  \"\"\"      expected_list = [\"<Layout\", 'columns=\"1 1', 'gap=\"1rem\"', \"<h1\", \"This is a layout section\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_layout_md_2(gui: Gui, helpers):      md_string = \"\"\"  <|layout.start|columns=1 1|gap=1rem|>  # This is a layout section  <|layout.end|>  \"\"\"      expected_list = [\"<Layout\", 'columns=\"1 1', 'gap=\"1rem\"', \"<h1\", \"This is a layout section\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_layout_html(gui: Gui, helpers):      html_string = '<taipy:layout columns=\"1 1\" gap=\"1rem\"><h1>This is a layout section</h1></taipy:layout>'      expected_list = [\"<Layout\", 'columns=\"1 1', 'gap=\"1rem\"', \"<h1\", \"This is a layout section\"]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_number_md_1(gui: Gui, helpers):      md_string = \"<|10|number|>\"      expected_list = [\"<Input\", 'value=\"10\"', 'type=\"number\"']      helpers.test_control_md(gui, md_string, expected_list)      def test_number_md_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"10\")      md_string = \"<|{x}|number|>\"      expected_list = [          \"<Input\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"10\"',          'type=\"number\"',          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_number_html_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      html_string = '<taipy:number value=\"{x}\" />'      expected_list = [          \"<Input\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"10\"',          'type=\"number\"',          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_number_html_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      html_string = \"<taipy:number>{x}</taipy:number>\"      expected_list = [          \"<Input\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"10\"',          'type=\"number\"',          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from datetime import datetime    from taipy.gui import Gui      def test_date_md_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"date\", datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"))      md_string = \"<|{date}|date|>\"      expected_list = [          \"<DateSelector\",          'defaultDate=\"2020-12-',          'updateVarName=\"_TpDt_tpec_TpExPr_date_TPMDL_0\"',          \"date={_TpDt_tpec_TpExPr_date_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_date_md_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"date\", datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"))      md_string = \"<|{date}|date|with_time|label=a label|>\"      expected_list = [          \"<DateSelector\",          'defaultDate=\"2020-12-',          'updateVarName=\"_TpDt_tpec_TpExPr_date_TPMDL_0\"',          \"date={_TpDt_tpec_TpExPr_date_TPMDL_0}\",          \"withTime={true}\",          'label=\"a label\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_date_html_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"date\", datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"))      html_string = '<taipy:date date=\"{date}\" />'      expected_list = [          \"<DateSelector\",          'defaultDate=\"2020-12-',          'updateVarName=\"_TpDt_tpec_TpExPr_date_TPMDL_0\"',          \"date={_TpDt_tpec_TpExPr_date_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_date_html_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"date\", datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"))      html_string = \"<taipy:date>{date}</taipy:date>\"      expected_list = [          \"<DateSelector\",          'defaultDate=\"2020-12-',          'updateVarName=\"_TpDt_tpec_TpExPr_date_TPMDL_0\"',          \"date={_TpDt_tpec_TpExPr_date_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_indicator_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"val\", 15)      md_string = \"<|12|indicator|value={val}|min=1|max=20|format=%.2f|>\"      expected_list = [          \"<Indicator\",          'libClassName=\"taipy-indicator\"',          \"defaultValue={15}\",          \"display={12.0}\",          'format=\"%.2f\"',          \"max={20.0}\",          \"min={1.0}\",          \"value={_TpN_tpec_TpExPr_val_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_menu_html(gui: Gui, test_client, helpers):      gui._bind_var_val(\"val\", 15)      html_string = '<taipy:indicator value=\"{val}\" min=\"1\" max=\"20\" format=\"%.2f\" >12</taipy:indicator>'      expected_list = [          \"<Indicator\",          'libClassName=\"taipy-indicator\"',          \"defaultValue={15}\",          \"display={12.0}\",          'format=\"%.2f\"',          \"max={20.0}\",          \"min={1.0}\",          \"value={_TpN_tpec_TpExPr_val_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_navbar_md(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"navlov\",          [              (\"/page1\", \"Page 1\"),              (\"/page2\", \"Page 2\"),              (\"/page3\", \"Page 3\"),              (\"/page4\", \"Page 4\"),          ],      )      md_string = \"<|navbar|lov={navlov}|>\"      expected_list = [          \"<NavBar\",          'defaultLov=\"[[&quot;/page1&quot;, &quot;Page 1&quot;], [&quot;/page2&quot;, &quot;Page 2&quot;], [&quot;/page3&quot;, &quot;Page 3&quot;], [&quot;/page4&quot;, &quot;Page 4&quot;]]\"',          \"lov={_TpL_tpec_TpExPr_navlov_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_navbar_html(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"navlov\",          [              (\"/page1\", \"Page 1\"),              (\"/page2\", \"Page 2\"),              (\"/page3\", \"Page 3\"),              (\"/page4\", \"Page 4\"),          ],      )      html_string = '<taipy:navbar lov=\"{navlov}\" />'      expected_list = [          \"<NavBar\",          'defaultLov=\"[[&quot;/page1&quot;, &quot;Page 1&quot;], [&quot;/page2&quot;, &quot;Page 2&quot;], [&quot;/page3&quot;, &quot;Page 3&quot;], [&quot;/page4&quot;, &quot;Page 4&quot;]]\"',          \"lov={_TpL_tpec_TpExPr_navlov_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_part_md_1(gui: Gui, helpers):      md_string = \"\"\"  <|part|class_name=class1|  # This is a part  |>  \"\"\"      expected_list = [\"<Part\", \"<h1\", \"This is a part\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_part_md_2(gui: Gui, helpers):      md_string = \"\"\"  <|part.start|class_name=class1|>  # This is a part  <|part.end|>  \"\"\"      expected_list = [\"<Part\", \"<h1\", \"This is a part\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_part_html(gui: Gui, helpers):      html_string = '<taipy:part class_name=\"class1\"><h1>This is a part</h1></taipy:part>'      expected_list = [\"<Part\", \"<h1\", \"This is a part\"]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from unittest.mock import Mock, patch    import pytest    from src.taipy.gui_core._context import _GuiCoreContext  from taipy.config.common.scope import Scope  from taipy.core import Job, Scenario, Task  from taipy.core.data.pickle import PickleDataNode    a_scenario = Scenario(\"scenario_config_id\", [], {}, sequences={\"sequence\": {}})  a_task = Task(\"task_config_id\", {}, print)  a_job = Job(\"JOB_job_id\", a_task, \"submit_id\", a_scenario.id)  a_job.isfinished = lambda s: True  a_datanode = PickleDataNode(\"data_node_config_id\", Scope.SCENARIO)      def mock_is_submittable_false(entity_id):      return False      def mock_is_true(entity_id):      return True      def mock_core_get(entity_id):      if entity_id == a_scenario.id:          return a_scenario      if entity_id == a_job.id:          return a_job      if entity_id == a_datanode.id:          return a_datanode      return a_task      class MockState:      def __init__(self, **kwargs) -> None:          self.assign = kwargs.get(\"assign\")      class TestGuiCoreContext_is_submittable:      def test_submit_entity(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get), patch(              \"src.taipy.gui_core._context.is_submittable\", side_effect=mock_is_true          ):              gui_core_context = _GuiCoreContext(Mock())              assign = Mock()              gui_core_context.submit_entity(                  MockState(assign=assign),                  \"\",                  {                      \"args\": [                          {\"name\": \"name\", \"id\": a_scenario.id},                      ]                  },              )              assign.assert_called_once()              assert assign.call_args.args[0] == \"gui_core_sv_error\"              assert str(assign.call_args.args[1]).startswith(\"Error submitting entity.\")                with patch(\"src.taipy.gui_core._context.is_submittable\", side_effect=mock_is_submittable_false):                  assign.reset_mock()                  gui_core_context.submit_entity(                      MockState(assign=assign),                      \"\",                      {                          \"args\": [                              {\"name\": \"name\", \"id\": a_scenario.id},                          ]                      },                  )                  assign.assert_called_once()                  assert assign.call_args.args[0] == \"gui_core_sv_error\"                  assert str(assign.call_args.args[1]).endswith(\"is not submittable.\") "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from unittest.mock import Mock, patch    import pytest    from src.taipy.gui_core._context import _GuiCoreContext  from taipy.config.common.scope import Scope  from taipy.core import Job, Scenario, Task  from taipy.core.data.pickle import PickleDataNode    a_scenario = Scenario(\"scenario_config_id\", [], {}, sequences={\"sequence\": {}})  a_task = Task(\"task_config_id\", {}, print)  a_job = Job(\"JOB_job_id\", a_task, \"submit_id\", a_scenario.id)  a_job.isfinished = lambda s: True  a_datanode = PickleDataNode(\"data_node_config_id\", Scope.SCENARIO)      def mock_core_get(entity_id):      if entity_id == a_scenario.id:          return a_scenario      if entity_id == a_job.id:          return a_job      if entity_id == a_datanode.id:          return a_datanode      return a_task      def mock_is_deletable_false(entity_id):      return False      def mock_is_true(entity_id):      return True      class MockState:      def __init__(self, **kwargs) -> None:          self.assign = kwargs.get(\"assign\")      class TestGuiCoreContext_is_deletable:      def test_crud_scenario(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get), patch(              \"src.taipy.gui_core._context.is_deletable\", side_effect=mock_is_true          ):              gui_core_context = _GuiCoreContext(Mock())              assign = Mock()              gui_core_context.crud_scenario(                  MockState(assign=assign),                  \"\",                  {                      \"args\": [                          True,                          True,                          {\"name\": \"name\", \"id\": a_scenario.id},                      ]                  },              )              assign.assert_called_once()              assert assign.call_args.args[0] == \"gui_core_sc_error\"              assert str(assign.call_args.args[1]).startswith(\"Error deleting Scenario.\")                with patch(\"src.taipy.gui_core._context.is_deletable\", side_effect=mock_is_deletable_false):                  assign.reset_mock()                  gui_core_context.crud_scenario(                      MockState(assign=assign),                      \"\",                      {                          \"args\": [                              True,                              True,                              {\"name\": \"name\", \"id\": a_scenario.id},                          ]                      },                  )                  assign.assert_called_once()                  assert assign.call_args.args[0] == \"gui_core_sc_error\"                  assert str(assign.call_args.args[1]).endswith(\"is not deletable.\")        def test_act_on_jobs(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get), patch(              \"src.taipy.gui_core._context.is_deletable\", side_effect=mock_is_true          ):              gui_core_context = _GuiCoreContext(Mock())              assign = Mock()              gui_core_context.act_on_jobs(                  MockState(assign=assign),                  \"\",                  {                      \"args\": [                          {\"id\": [a_job.id], \"action\": \"delete\"},                      ]                  },              )              assign.assert_called_once()              assert assign.call_args.args[0] == \"gui_core_js_error\"              assert str(assign.call_args.args[1]).find(\"is not deletable.\") == -1              assign.reset_mock()                with patch(\"src.taipy.gui_core._context.is_readable\", side_effect=mock_is_deletable_false):                  gui_core_context.act_on_jobs(                      MockState(assign=assign),                      \"\",                      {                          \"args\": [                              {\"id\": [a_job.id], \"action\": \"delete\"},                          ]                      },                  )                  assign.assert_called_once()                  assert assign.call_args.args[0] == \"gui_core_js_error\"                  assert str(assign.call_args.args[1]).endswith(\"is not readable.\") "}
{"text": "from unittest.mock import Mock, patch    import pytest    from src.taipy.gui_core._context import _GuiCoreContext  from taipy.config.common.scope import Scope  from taipy.core import Job, Scenario, Task  from taipy.core.data.pickle import PickleDataNode    a_scenario = Scenario(\"scenario_config_id\", [], {}, sequences={\"sequence\": {}})  a_task = Task(\"task_config_id\", {}, print)  a_job = Job(\"JOB_job_id\", a_task, \"submit_id\", a_scenario.id)  a_job.isfinished = lambda s: True  a_datanode = PickleDataNode(\"data_node_config_id\", Scope.SCENARIO)      def mock_core_get(entity_id):      if entity_id == a_scenario.id:          return a_scenario      if entity_id == a_job.id:          return a_job      if entity_id == a_datanode.id:          return a_datanode      return a_task      def mock_is_promotable_false(entity_id):      return False      def mock_is_true(entity_id):      return True      class MockState:      def __init__(self, **kwargs) -> None:          self.assign = kwargs.get(\"assign\")      class TestGuiCoreContext_is_promotable:      def test_edit_entity(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get), patch(              \"src.taipy.gui_core._context.is_promotable\", side_effect=mock_is_true          ):              gui_core_context = _GuiCoreContext(Mock())              assign = Mock()              gui_core_context.edit_entity(                  MockState(assign=assign),                  \"\",                  {                      \"args\": [                          {\"name\": \"name\", \"id\": a_scenario.id, \"primary\": True},                      ]                  },              )              assign.assert_called_once()              assert assign.call_args.args[0] == \"gui_core_sv_error\"              assert str(assign.call_args.args[1]).endswith(\"to primary because it doesn't belong to a cycle.\")              assign.reset_mock()                with patch(\"src.taipy.gui_core._context.is_promotable\", side_effect=mock_is_promotable_false):                  gui_core_context.edit_entity(                      MockState(assign=assign),                      \"\",                      {                          \"args\": [                              {\"name\": \"name\", \"id\": a_scenario.id, \"primary\": True},                          ]                      },                  )                  assign.assert_called_once()                  assert assign.call_args.args[0] == \"gui_core_sv_error\"                  assert str(assign.call_args.args[1]).endswith(\"is not promotable.\") "}
{"text": "from unittest import mock    import pytest  from flask import url_for    from src.taipy.rest.api.exceptions.exceptions import ScenarioIdMissingException, SequenceNameMissingException  from taipy.core.exceptions.exceptions import NonExistingScenario  from taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory      def test_get_sequence(client, default_sequence):      # test 404      user_url = url_for(\"api.sequence_by_id\", sequence_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.sequence._sequence_manager._SequenceManager._get\") as manager_mock:          manager_mock.return_value = default_sequence            # test get_sequence          rep = client.get(url_for(\"api.sequence_by_id\", sequence_id=\"foo\"))          assert rep.status_code == 200      def test_delete_sequence(client):      # test 404      user_url = url_for(\"api.sequence_by_id\", sequence_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.sequence._sequence_manager._SequenceManager._delete\"), mock.patch(          \"taipy.core.sequence._sequence_manager._SequenceManager._get\"      ):          # test get_sequence          rep = client.delete(url_for(\"api.sequence_by_id\", sequence_id=\"foo\"))          assert rep.status_code == 200      def test_create_sequence(client, default_scenario):      sequences_url = url_for(\"api.sequences\")      rep = client.post(sequences_url, json={})      assert rep.status_code == 400      assert rep.json == {\"message\": \"Scenario id is missing.\"}        sequences_url = url_for(\"api.sequences\")      rep = client.post(sequences_url, json={\"scenario_id\": \"SCENARIO_scenario_id\"})      assert rep.status_code == 400      assert rep.json == {\"message\": \"Sequence name is missing.\"}        sequences_url = url_for(\"api.sequences\")      rep = client.post(sequences_url, json={\"scenario_id\": \"SCENARIO_scenario_id\", \"sequence_name\": \"sequence\"})      assert rep.status_code == 404        _ScenarioManagerFactory._build_manager()._set(default_scenario)      with mock.patch(\"taipy.core.scenario._scenario_manager._ScenarioManager._get\") as config_mock:          config_mock.return_value = default_scenario          sequences_url = url_for(\"api.sequences\")          rep = client.post(              sequences_url, json={\"scenario_id\": default_scenario.id, \"sequence_name\": \"sequence\", \"tasks\": []}          )          assert rep.status_code == 201      def test_get_all_sequences(client, default_scenario_config_list):      for ds in range(10):          with mock.patch(\"src.taipy.rest.api.resources.scenario.ScenarioList.fetch_config\") as config_mock:              config_mock.return_value = default_scenario_config_list[ds]              scenario_url = url_for(\"api.scenarios\", config_id=config_mock.name)              client.post(scenario_url)        sequences_url = url_for(\"api.sequences\")      rep = client.get(sequences_url)      assert rep.status_code == 200        results = rep.get_json()      assert len(results) == 10      @pytest.mark.xfail()  def test_execute_sequence(client, default_sequence):      # test 404      user_url = url_for(\"api.sequence_submit\", sequence_id=\"foo\")      rep = client.post(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.sequence._sequence_manager._SequenceManager._get\") as manager_mock:          manager_mock.return_value = default_sequence            # test get_sequence          rep = client.post(url_for(\"api.sequence_submit\", sequence_id=\"foo\"))          assert rep.status_code == 200 "}
{"text": "from unittest import mock    from flask import url_for      def test_get_job(client, default_job):      # test 404      user_url = url_for(\"api.job_by_id\", job_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.job._job_manager._JobManager._get\") as manager_mock:          manager_mock.return_value = default_job            # test get_job          rep = client.get(url_for(\"api.job_by_id\", job_id=\"foo\"))          assert rep.status_code == 200      def test_delete_job(client):      # test 404      user_url = url_for(\"api.job_by_id\", job_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.job._job_manager._JobManager._delete\"), mock.patch(          \"taipy.core.job._job_manager._JobManager._get\"      ):          # test get_job          rep = client.delete(url_for(\"api.job_by_id\", job_id=\"foo\"))          assert rep.status_code == 200      def test_create_job(client, default_task_config):      # without config param      jobs_url = url_for(\"api.jobs\")      rep = client.post(jobs_url)      assert rep.status_code == 400        with mock.patch(\"src.taipy.rest.api.resources.job.JobList.fetch_config\") as config_mock:          config_mock.return_value = default_task_config          jobs_url = url_for(\"api.jobs\", task_id=\"foo\")          rep = client.post(jobs_url)          assert rep.status_code == 201      def test_get_all_jobs(client, create_job_list):      jobs_url = url_for(\"api.jobs\")      rep = client.get(jobs_url)      assert rep.status_code == 200        results = rep.get_json()      assert len(results) == 10      def test_cancel_job(client, default_job):      # test 404      from taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory        _OrchestratorFactory._build_orchestrator()      _OrchestratorFactory._build_dispatcher()        user_url = url_for(\"api.job_cancel\", job_id=\"foo\")      rep = client.post(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.job._job_manager._JobManager._get\") as manager_mock:          manager_mock.return_value = default_job            # test get_job          rep = client.post(url_for(\"api.job_cancel\", job_id=\"foo\"))          assert rep.status_code == 200 "}
{"text": "from unittest import mock    from flask import url_for      def test_get_task(client, default_task):      # test 404      user_url = url_for(\"api.task_by_id\", task_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.task._task_manager._TaskManager._get\") as manager_mock:          manager_mock.return_value = default_task            # test get_task          rep = client.get(url_for(\"api.task_by_id\", task_id=\"foo\"))          assert rep.status_code == 200      def test_delete_task(client):      # test 404      user_url = url_for(\"api.task_by_id\", task_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.task._task_manager._TaskManager._delete\"), mock.patch(          \"taipy.core.task._task_manager._TaskManager._get\"      ):          # test get_task          rep = client.delete(url_for(\"api.task_by_id\", task_id=\"foo\"))          assert rep.status_code == 200      def test_create_task(client, default_task_config):      # without config param      tasks_url = url_for(\"api.tasks\")      rep = client.post(tasks_url)      assert rep.status_code == 400        # config does not exist      tasks_url = url_for(\"api.tasks\", config_id=\"foo\")      rep = client.post(tasks_url)      assert rep.status_code == 404        with mock.patch(\"src.taipy.rest.api.resources.task.TaskList.fetch_config\") as config_mock:          config_mock.return_value = default_task_config          tasks_url = url_for(\"api.tasks\", config_id=\"bar\")          rep = client.post(tasks_url)          assert rep.status_code == 201      def test_get_all_tasks(client, task_data, default_task_config_list):      for ds in range(10):          with mock.patch(\"src.taipy.rest.api.resources.task.TaskList.fetch_config\") as config_mock:              config_mock.return_value = default_task_config_list[ds]              tasks_url = url_for(\"api.tasks\", config_id=config_mock.name)              client.post(tasks_url)        rep = client.get(tasks_url)      assert rep.status_code == 200        results = rep.get_json()      assert len(results) == 10      def test_execute_task(client, default_task):      # test 404      user_url = url_for(\"api.task_submit\", task_id=\"foo\")      rep = client.post(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.task._task_manager._TaskManager._get\") as manager_mock:          manager_mock.return_value = default_task            # test get_task          rep = client.post(url_for(\"api.task_submit\", task_id=\"foo\"))          assert rep.status_code == 200 "}
{"text": "from functools import wraps  from unittest.mock import MagicMock, patch    from src.taipy.rest.api.middlewares._middleware import _middleware      def mock_enterprise_middleware(f):      @wraps(f)      def wrapper(*args, **kwargs):          return f(*args, **kwargs)        return wrapper      @patch(\"src.taipy.rest.api.middlewares._middleware._using_enterprise\")  @patch(\"src.taipy.rest.api.middlewares._middleware._enterprise_middleware\")  def test_enterprise_middleware_applied_when_enterprise_is_installed(      enterprise_middleware: MagicMock, using_enterprise: MagicMock  ):      enterprise_middleware.return_value = mock_enterprise_middleware      using_enterprise.return_value = True        @_middleware      def f():          return \"f\"        rv = f()      assert rv == \"f\"      using_enterprise.assert_called_once()      enterprise_middleware.assert_called_once()      @patch(\"src.taipy.rest.api.middlewares._middleware._using_enterprise\")  @patch(\"src.taipy.rest.api.middlewares._middleware._enterprise_middleware\")  def test_enterprise_middleware_not_applied_when_enterprise_is_not_installed(      enterprise_middleware: MagicMock, using_enterprise: MagicMock  ):      enterprise_middleware.return_value = mock_enterprise_middleware      using_enterprise.return_value = False        @_middleware      def f():          return \"f\"        rv = f()      assert rv == \"f\"      using_enterprise.assert_called_once()      enterprise_middleware.assert_not_called() "}
{"text": "from unittest import mock    import pytest  from flask import url_for      def test_get_datanode(client, default_datanode):      # test 404      user_url = url_for(\"api.datanode_by_id\", datanode_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.data._data_manager._DataManager._get\") as manager_mock:          manager_mock.return_value = default_datanode          # test get_datanode          rep = client.get(url_for(\"api.datanode_by_id\", datanode_id=\"foo\"))          assert rep.status_code == 200      def test_delete_datanode(client):      # test 404      user_url = url_for(\"api.datanode_by_id\", datanode_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.data._data_manager._DataManager._delete\"), mock.patch(          \"taipy.core.data._data_manager._DataManager._get\"      ):          # test get_datanode          rep = client.delete(url_for(\"api.datanode_by_id\", datanode_id=\"foo\"))          assert rep.status_code == 200      def test_create_datanode(client, default_datanode_config):      # without config param      datanodes_url = url_for(\"api.datanodes\")      rep = client.post(datanodes_url)      assert rep.status_code == 400        # config does not exist      datanodes_url = url_for(\"api.datanodes\", config_id=\"foo\")      rep = client.post(datanodes_url)      assert rep.status_code == 404        with mock.patch(\"src.taipy.rest.api.resources.datanode.DataNodeList.fetch_config\") as config_mock:          config_mock.return_value = default_datanode_config          datanodes_url = url_for(\"api.datanodes\", config_id=\"bar\")          rep = client.post(datanodes_url)          assert rep.status_code == 201      def test_get_all_datanodes(client, default_datanode_config_list):      for ds in range(10):          with mock.patch(\"src.taipy.rest.api.resources.datanode.DataNodeList.fetch_config\") as config_mock:              config_mock.return_value = default_datanode_config_list[ds]              datanodes_url = url_for(\"api.datanodes\", config_id=config_mock.name)              client.post(datanodes_url)        rep = client.get(datanodes_url)      assert rep.status_code == 200        results = rep.get_json()      assert len(results) == 10      def test_read_datanode(client, default_df_datanode):      with mock.patch(\"taipy.core.data._data_manager._DataManager._get\") as config_mock:          config_mock.return_value = default_df_datanode            # without operators          datanodes_url = url_for(\"api.datanode_reader\", datanode_id=\"foo\")          rep = client.get(datanodes_url, json={})          assert rep.status_code == 200            # Without operators and body          rep = client.get(datanodes_url)          assert rep.status_code == 200            # TODO: Revisit filter test          # operators = {\"operators\": [{\"key\": \"a\", \"value\": 5, \"operator\": \"LESS_THAN\"}]}          # rep = client.get(datanodes_url, json=operators)          # assert rep.status_code == 200      def test_write_datanode(client, default_datanode):      with mock.patch(\"taipy.core.data._data_manager._DataManager._get\") as config_mock:          config_mock.return_value = default_datanode          # Get DataNode          datanodes_read_url = url_for(\"api.datanode_reader\", datanode_id=default_datanode.id)          rep = client.get(datanodes_read_url, json={})          assert rep.status_code == 200          assert rep.json == {\"data\": [1, 2, 3, 4, 5, 6]}            datanodes_write_url = url_for(\"api.datanode_writer\", datanode_id=default_datanode.id)          rep = client.put(datanodes_write_url, json=[1, 2, 3])          assert rep.status_code == 200            rep = client.get(datanodes_read_url, json={})          assert rep.status_code == 200          assert rep.json == {\"data\": [1, 2, 3]} "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import json  from typing import Dict    from flask import url_for      def create_and_submit_scenario(config_id: str, client) -> Dict:      response = client.post(url_for(\"api.scenarios\", config_id=config_id))      assert response.status_code == 201        scenario = response.json.get(\"scenario\")      assert (set(scenario) - set(json.load(open(\"tests/rest/json/expected/scenario.json\")))) == set()        response = client.post(url_for(\"api.scenario_submit\", scenario_id=scenario.get(\"id\")))      assert response.status_code == 200        return scenario      def get(url, name, client) -> Dict:      response = client.get(url)      returned_data = response.json.get(name)        assert (set(returned_data) - set(json.load(open(f\"tests/rest/json/expected/{name}.json\")))) == set()        return returned_data      def get_assert_status(url, client, status_code) -> None:      response = client.get(url)      assert response.status_code == status_code      def get_all(url, expected_quantity, client):      response = client.get(url)        assert len(response.json) == expected_quantity      def delete(url, client):      response = client.delete(url)        assert response.status_code == 200      def test_end_to_end(client, setup_end_to_end):      # Create Scenario: Should also create all of its dependencies(sequences, tasks, datanodes, etc)      scenario = create_and_submit_scenario(\"scenario\", client)        # Get other models and verify if they return the necessary fields      cycle = get(url_for(\"api.cycle_by_id\", cycle_id=scenario.get(\"cycle\")), \"cycle\", client)      sequence = get(          url_for(\"api.sequence_by_id\", sequence_id=f\"SEQUENCE_sequence_{scenario['id']}\"),          \"sequence\",          client,      )      task = get(url_for(\"api.task_by_id\", task_id=sequence.get(\"tasks\")[0]), \"task\", client)      datanode = get(          url_for(\"api.datanode_by_id\", datanode_id=task.get(\"input_ids\")[0]),          \"datanode\",          client,      )      # Get All      get_all(url_for(\"api.scenarios\"), 1, client)      get_all(url_for(\"api.cycles\"), 1, client)      get_all(url_for(\"api.sequences\"), 1, client)      get_all(url_for(\"api.tasks\"), 2, client)      get_all(url_for(\"api.datanodes\"), 5, client)      get_all(url_for(\"api.jobs\"), 2, client)        # Delete entities      delete(url_for(\"api.cycle_by_id\", cycle_id=cycle.get(\"id\")), client)      delete(url_for(\"api.sequence_by_id\", sequence_id=sequence.get(\"id\")), client)      delete(url_for(\"api.task_by_id\", task_id=task.get(\"id\")), client)      delete(url_for(\"api.datanode_by_id\", datanode_id=datanode.get(\"id\")), client)        # Check status code      # Non-existing entities should return 404      get_assert_status(url_for(\"api.cycle_by_id\", cycle_id=9999999), client, 404)      get_assert_status(url_for(\"api.scenario_by_id\", scenario_id=9999999), client, 404)      get_assert_status(url_for(\"api.sequence_by_id\", sequence_id=9999999), client, 404)      get_assert_status(url_for(\"api.task_by_id\", task_id=9999999), client, 404)      get_assert_status(url_for(\"api.datanode_by_id\", datanode_id=9999999), client, 404)        # Check URL with and without trailing slashes      url_with_slash = url_for(\"api.scenarios\")      url_without_slash = url_for(\"api.scenarios\")[:-1]      get_all(url_with_slash, 1, client)      get_all(url_without_slash, 1, client) "}
{"text": "from unittest import mock    from flask import url_for      def test_get_cycle(client, default_cycle):      # test 404      cycle_url = url_for(\"api.cycle_by_id\", cycle_id=\"foo\")      rep = client.get(cycle_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.cycle._cycle_manager._CycleManager._get\") as manager_mock:          manager_mock.return_value = default_cycle            # test get_cycle          rep = client.get(url_for(\"api.cycle_by_id\", cycle_id=\"foo\"))          assert rep.status_code == 200      def test_delete_cycle(client):      # test 404      cycle_url = url_for(\"api.cycle_by_id\", cycle_id=\"foo\")      rep = client.get(cycle_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.cycle._cycle_manager._CycleManager._delete\"), mock.patch(          \"taipy.core.cycle._cycle_manager._CycleManager._get\"      ):          # test get_cycle          rep = client.delete(url_for(\"api.cycle_by_id\", cycle_id=\"foo\"))          assert rep.status_code == 200      def test_create_cycle(client, cycle_data):      # without config param      cycles_url = url_for(\"api.cycles\")      data = {\"bad\": \"data\"}      rep = client.post(cycles_url, json=data)      assert rep.status_code == 400        rep = client.post(cycles_url, json=cycle_data)      assert rep.status_code == 201      def test_get_all_cycles(client, create_cycle_list):      cycles_url = url_for(\"api.cycles\")      rep = client.get(cycles_url)      assert rep.status_code == 200        results = rep.get_json()      assert len(results) == 10 "}
{"text": "from unittest import mock    import pytest  from flask import url_for      def test_get_scenario(client, default_scenario):      # test 404      user_url = url_for(\"api.scenario_by_id\", scenario_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.scenario._scenario_manager._ScenarioManager._get\") as manager_mock:          manager_mock.return_value = default_scenario            # test get_scenario          rep = client.get(url_for(\"api.scenario_by_id\", scenario_id=\"foo\"))          assert rep.status_code == 200      def test_delete_scenario(client):      # test 404      user_url = url_for(\"api.scenario_by_id\", scenario_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.scenario._scenario_manager._ScenarioManager._delete\"), mock.patch(          \"taipy.core.scenario._scenario_manager._ScenarioManager._get\"      ):          # test get_scenario          rep = client.delete(url_for(\"api.scenario_by_id\", scenario_id=\"foo\"))          assert rep.status_code == 200      def test_create_scenario(client, default_scenario_config):      # without config param      scenarios_url = url_for(\"api.scenarios\")      rep = client.post(scenarios_url)      assert rep.status_code == 400        # config does not exist      scenarios_url = url_for(\"api.scenarios\", config_id=\"foo\")      rep = client.post(scenarios_url)      assert rep.status_code == 404        with mock.patch(\"src.taipy.rest.api.resources.scenario.ScenarioList.fetch_config\") as config_mock:          config_mock.return_value = default_scenario_config          scenarios_url = url_for(\"api.scenarios\", config_id=\"bar\")          rep = client.post(scenarios_url)          assert rep.status_code == 201      def test_get_all_scenarios(client, default_sequence, default_scenario_config_list):      for ds in range(10):          with mock.patch(\"src.taipy.rest.api.resources.scenario.ScenarioList.fetch_config\") as config_mock:              config_mock.return_value = default_scenario_config_list[ds]              scenarios_url = url_for(\"api.scenarios\", config_id=config_mock.name)              client.post(scenarios_url)        rep = client.get(scenarios_url)      assert rep.status_code == 200        results = rep.get_json()      assert len(results) == 10      @pytest.mark.xfail()  def test_execute_scenario(client, default_scenario):      # test 404      user_url = url_for(\"api.scenario_submit\", scenario_id=\"foo\")      rep = client.post(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.scenario._scenario_manager._ScenarioManager._get\") as manager_mock:          manager_mock.return_value = default_scenario            # test get_scenario          rep = client.post(url_for(\"api.scenario_submit\", scenario_id=\"foo\"))          assert rep.status_code == 200 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import pickle  import random  from datetime import datetime, timedelta  from typing import Any, Dict    import pandas as pd    n_predictions = 14      def forecast(model, date: datetime):      dates = [date + timedelta(days=i) for i in range(n_predictions)]      forecasts = [f + random.uniform(0, 2) for f in model.forecast(len(dates))]      days = [str(dt.date()) for dt in dates]      res = {\"Date\": days, \"Forecast\": forecasts}      return pd.DataFrame.from_dict(res)      def evaluate(cleaned: pd.DataFrame, forecasts: pd.DataFrame, date: datetime) -> Dict[str, Any]:      cleaned = cleaned[cleaned[\"Date\"].isin(forecasts[\"Date\"].tolist())]      forecasts_as_series = pd.Series(forecasts[\"Forecast\"].tolist(), name=\"Forecast\")      res = pd.concat([cleaned.reset_index(), forecasts_as_series], axis=1)      res[\"Delta\"] = abs(res[\"Forecast\"] - res[\"Value\"])        return {          \"Date\": date,          \"Dataframe\": res,          \"Mean_absolute_error\": res[\"Delta\"].mean(),          \"Relative_error\": (res[\"Delta\"].mean() * 100) / res[\"Value\"].mean(),      }      if __name__ == \"__main__\":      model = pickle.load(open(\"../my_model.p\", \"rb\"))      day = datetime(2020, 1, 25)      forecasts = forecast(model, day)        historical_temperature = pd.read_csv(\"../historical_temperature.csv\")      evaluation = evaluate(historical_temperature, forecasts, day)        print(evaluation[\"Dataframe\"])      print()      print(f'Mean absolute error : {evaluation[\"Mean_absolute_error\"]}')      print(f'Relative error in %: {evaluation[\"Relative_error\"]}') "}
{"text": "from taipy.core import Config, Frequency    from .algorithms import evaluate, forecast    model_cfg = Config.configure_data_node(\"model\", path=\"my_model.p\", storage_type=\"pickle\")    day_cfg = Config.configure_data_node(id=\"day\")  forecasts_cfg = Config.configure_data_node(id=\"forecasts\")  forecast_task_cfg = Config.configure_task(      id=\"forecast_task\",      input=[model_cfg, day_cfg],      function=forecast,      output=forecasts_cfg,  )    historical_temperature_cfg = Config.configure_data_node(      \"historical_temperature\",      storage_type=\"csv\",      path=\"historical_temperature.csv\",      has_header=True,  )  evaluation_cfg = Config.configure_data_node(\"evaluation\")  evaluate_task_cfg = Config.configure_task(      \"evaluate_task\",      input=[historical_temperature_cfg, forecasts_cfg, day_cfg],      function=evaluate,      output=evaluation_cfg,  )    scenario_cfg = Config.configure_scenario(\"scenario\", [forecast_task_cfg, evaluate_task_cfg], frequency=Frequency.DAILY)  scenario_cfg.add_sequences({\"sequence\": [forecast_task_cfg, evaluate_task_cfg]}) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import random  import string    from example_library import ExampleLibrary  from taipy.gui import Gui    # Initial value  label = \"Here is some text\"    page = \"\"\"  # Custom elements example    ## Fraction:    No denominator: <|123|example.fraction|>    Denominator is 0: <|321|example.fraction|denominator=0|>    Regular: <|355|example.fraction|denominator=113|>    ## Custom label:    Colored text: <|{label}|example.label|>    <|Add a character|button|id=addChar|>  <|Remove a character|button|id=removeChar|>  \"\"\"      def on_action(state, id):      if id == \"addChar\":          # Add a random character to the end of 'label'          state.label += random.choice(string.ascii_letters)      elif id == \"removeChar\":          # Remove the first character of 'label'          if len(state.label) > 0:              state.label = state.label[1:]      Gui(page, libraries=[ExampleLibrary()]).run(debug=True) "}
{"text": "from .example_library import ExampleLibrary "}
{"text": "from taipy.gui.extension import Element, ElementLibrary, ElementProperty, PropertyType      class ExampleLibrary(ElementLibrary):      def __init__(self) -> None:          # Initialize the set of visual elements for this extension library          self.elements = {              # A static element that displays its properties in a fraction              \"fraction\": Element(                  \"numerator\",                  {                      \"numerator\": ElementProperty(PropertyType.number),                      \"denominator\": ElementProperty(PropertyType.number),                  },                  render_xhtml=ExampleLibrary._fraction_render,              ),              # A dynamic element that decorates its value              \"label\": Element(                  \"value\",                  {\"value\": ElementProperty(PropertyType.dynamic_string)},                  # The name of the React component (ColoredLabel) that implements this custom                  # element, exported as ExampleLabel in front-end/src/index.ts                  react_component=\"ExampleLabel\",              ),          }        # The implementation of the rendering for the \"fraction\" static element      @staticmethod      def _fraction_render(props: dict) -> str:          # Get the property values          numerator = props.get(\"numerator\")          denominator = props.get(\"denominator\")          # No denominator or numerator is 0: display the numerator          if denominator is None or int(numerator) == 0:              return f\"<span>{numerator}</span>\"          # Denominator is zero: display infinity          if int(denominator) == 0:              return '<span style=\"font-size: 1.6em\">&#8734;</span>'          # 'Normal' case          return f\"<span><sup>{numerator}</sup>/<sub>{denominator}</sub></span>\"        def get_name(self) -> str:          return \"example\"        def get_elements(self) -> dict:          return self.elements        def get_scripts(self) -> list[str]:          # Only one JavaScript bundle for this library.          return [\"front-end/dist/exampleLibrary.js\"] "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  # Demonstrate how to share variable values across multiple clients.  # This application creates a thread that increments a value every few seconds.  # The value is updated for every client using the state.broadcast() method.  # The text of the button that starts or stops the thread is updated on every client's browser  # using a direct assignment of the state property because the variable is declared 'shared'.  # -----------------------------------------------------------------------------------------  from threading import Event, Thread  from time import sleep    from taipy.gui import Gui, State, broadcast_callback    counter = 0    # Thread management  thread = None  thread_event = Event()    button_texts = [\"Start\", \"Stop\"]  # Text in the start/stop button (initially \"Start\")  button_text = button_texts[0]      # Invoked by the timer  def update_counter(state: State, c):      # Update all clients      state.broadcast(\"counter\", c)      def count(event, gui):      while not event.is_set():          global counter          counter = counter + 1          broadcast_callback(gui, update_counter, [counter])          sleep(2)      # Start or stop the timer when the button is pressed  def start_or_stop(state):      global thread      if thread:  # Timer is running          thread_event.set()          thread = None      else:  # Timer is stopped          thread_event.clear()          thread = Thread(target=count, args=[thread_event, state.get_gui()])          thread.start()      # Update button status.      # Because \"button_text\" is shared, all clients are updated      state.button_text = button_texts[1 if thread else 0]      page = \"\"\"# Broadcasting values    Counter: <|{counter}|>    Timer: <|{button_text}|button|on_action=start_or_stop|>  \"\"\"    # Declare \"button_text\" as a shared variable.  # Assigning a value to a state's 'button_text' property is propagated to all clients  Gui.add_shared_variable(\"button_text\")    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  # Demonstrates the use of the 'rebuild' property of the 'chart' control  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # x values: [-10..10]  x_range = range(-10, 11)  data = {\"X\": x_range, \"Y\": [x * x for x in x_range]}    types = [(\"bar\", \"Bar\"), (\"line\", \"Line\")]  selected_type = types[0]    page = \"\"\"  <|{data}|chart|type={selected_type[0]}|x=X|y=Y|rebuild|>    <|{selected_type}|toggle|lov={types}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import datetime    from taipy.gui import Gui    # Tasks definitions  tasks = [\"Plan\", \"Research\", \"Design\", \"Implement\", \"Test\", \"Deliver\"]  # Task durations, in days  durations = [50, 30, 30, 40, 15, 10]  # Planned start dates of tasks  start_dates = [      datetime.date(2022, 10, 15),  # Plan      datetime.date(2022, 11, 7),  # Research      datetime.date(2022, 12, 1),  # Design      datetime.date(2022, 12, 20),  # Implement      datetime.date(2023, 1, 15),  # Test      datetime.date(2023, 2, 1),  # Deliver  ]    epoch = datetime.date(1970, 1, 1)    data = {      \"start\": start_dates,      \"Task\": tasks,      # Compute the time span as adatetime (relative to January 1st, 1970)      \"Date\": [epoch + datetime.timedelta(days=duration) for duration in durations],  }    layout = {      \"yaxis\": {          # Sort tasks from top to bottom          \"autorange\": \"reversed\",          # Remove title          \"title\": {\"text\": \"\"},      },  }    page = \"\"\"  # Gantt - Simple    <|{data}|chart|type=bar|orientation=h|y=Task|x=Date|base=start|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # x values are [-10..10]  x_range = range(-10, 11)    # The data set that holds both the x and the y values  data = {\"X\": x_range, \"Y\": [x * x for x in x_range]}    page = \"\"\"  # Basics - X range    <|{data}|chart|x=X|y=Y|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui      # Function to plot: x^3/3-x  def f(x):      return x * x * x / 3 - x      # x values: [-2.2, ..., 2.2]  x = [(x - 10) / 4.5 for x in range(0, 21)]    data = {      \"x\": x,      # y: [f(-2.2), ..., f(2.2)]      \"y\": [f(x) for x in x],  }    shape_size = 0.1    layout = {      \"shapes\": [          # Shape for local maximum (x = -1)          {              \"x0\": -1 - shape_size,              \"y0\": f(-1) - 2 * shape_size,              \"x1\": -1 + shape_size,              \"y1\": f(-1) + 2 * shape_size,              \"fillcolor\": \"green\",              \"opacity\": 0.5,          },          # Shape for local minimum (x = 1)          {              \"x0\": 1 - shape_size,              \"y0\": f(1) - 2 * shape_size,              \"x1\": 1 + shape_size,              \"y1\": f(1) + 2 * shape_size,              \"fillcolor\": \"red\",              \"opacity\": 0.5,          },      ]  }    page = \"\"\"  # Advanced - Annotations    <|{data}|chart|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import numpy    from taipy.gui import Gui      # Return the x and y coordinates of the spiral for the given angle  def spiral(th):      a = 1.120529      b = 0.306349      r = a * numpy.exp(-b * th)      return (r * numpy.cos(th), r * numpy.sin(th))      # Prepare Golden spiral data as a parametric curve  (x, y) = spiral(numpy.linspace(-numpy.pi / 13, 4 * numpy.pi, 1000))    # Prepare the heatmap x and y cell sizes along the axes  golden_ratio = (1 + numpy.sqrt(5)) / 2.0  # Golden ratio  grid_x = [0, 1, 1 + (1 / (golden_ratio ** 4)), 1 + (1 / (golden_ratio ** 3)), golden_ratio]  grid_y = [0, 1 / (golden_ratio ** 3), 1 / golden_ratio ** 3 + 1 / golden_ratio ** 4, 1 / (golden_ratio ** 2), 1]    # Main value is based on the Fibonacci sequence  z = [[13, 3, 3, 5], [13, 2, 1, 5], [13, 10, 11, 12], [13, 8, 8, 8]]    # Group all data sets in a single array  data = [      {          \"z\": z,      },      {\"x\": numpy.sort(grid_x), \"y\": numpy.sort(grid_y)},      {          \"xSpiral\": -x + x[0],          \"ySpiral\": y - y[0],      },  ]    # Axis template: hide all ticks, lines and labels  axis = {\"range\": [0, 2.0], \"showgrid\": False, \"zeroline\": False, \"showticklabels\": False, \"ticks\": \"\", \"title\": \"\"}    layout = {      # Use the axis template for both x and y axes      \"xaxis\": axis,      \"yaxis\": axis,  }    options = {      # Hide the color scale of the heatmap      \"showscale\": False  }    # Chart holds two traces, with different types  types = [\"heatmap\", \"scatter\"]  # x and y values for both traces  xs = [\"1/x\", \"2/xSpiral\"]  ys = [\"1/y\", \"2/ySpiral\"]    page = \"\"\"  ## Heatmap - Drawing on top    <|{data}|chart|type={types}|z[1]=0/z|x={xs}|y={ys}|layout={layout}|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    from taipy.gui import Gui    # Data set made of two series of random numbers  data = {\"A\": [random.random() for i in range(200)], \"B\": [random.random() for i in range(200)]}    # Names of the two traces  names = [\"A samples\", \"B samples\"]    layout = {      # Make the histogram stack the data sets      \"barmode\": \"stack\"  }    page = \"\"\"  # Histogram - Stacked    <|{data}|chart|type=histogram|x[1]=A|x[2]=B|name={names}|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Data set  data = {      \"Day\": [\"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\"],      \"Values\": [10, -5, 20, -10, 30],      \"Measure\": [\"absolute\", \"relative\", \"relative\", \"relative\", \"relative\"],  }    page = \"\"\"  # Waterfall - Simple    <|{data}|chart|type=waterfall|x=Day|y=Values|measure=Measure|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    n_slices = 20  # List: [1..n_slices]  # Slices are bigger and bigger  values = list(range(1, n_slices + 1))    marker = {      # Colors move around the Hue color disk      \"colors\": [f\"hsl({360 * (i - 1)/(n_slices - 1)},90%,60%)\" for i in values]  }    layout = {      # Hide the legend      \"showlegend\": False  }    options = {      # Hide the texts      \"textinfo\": \"none\"  }    page = \"\"\"  # Pie - Style    <|{values}|chart|type=pie|marker={marker}|options={options}|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from datetime import datetime    import numpy  from taipy.gui import Gui      def generate_hand_shapes():      # Retrieve and store the current, local time      time_now = datetime.now()      hours = time_now.hour      minutes = time_now.minute      seconds = time_now.second        # Compute the angle that represents the hours      hours_angle = 360 * ((hours % 12) / 12 + (minutes % 60) / 60 / 60 + (seconds % 60) / 60 / 60 / 60)      # Short and thick hand for the hours      hours_hand = {\"r\": [0, 4, 5, 4, 0], \"a\": [0, hours_angle - 7, hours_angle, hours_angle + 7, 0]}        # Compute the angle that represents the minutes      minutes_angle = 360 * ((minutes % 60) / 60 + (seconds % 60) / 60 / 60)      # Longer and slighly thinner hand for the minutes      minutes_hand = {\"r\": [0, 6, 8, 6, 0], \"a\": [0, minutes_angle - 4, minutes_angle, minutes_angle + 4, 0]}        # Compute the angle that represents the seconds      seconds_angle = 360 * (seconds % 60) / 60      # Even longer and thinner hand for the seconds      seconds_hand = {\"r\": [0, 8, 10, 8, 0], \"a\": [0, seconds_angle - 2, seconds_angle, seconds_angle + 2, 0]}      # Build and return the whole data set      return [hours_hand, minutes_hand, seconds_hand]      # Initialize the data set with the current time  data = generate_hand_shapes()    layout = {      \"polar\": {          \"angularaxis\": {              \"rotation\": 90,              \"direction\": \"clockwise\",              # One tick every 30 degrees              \"tickvals\": list(numpy.arange(0.0, 360.0, 30)),              # Text value for every tick              \"ticktext\": [\"XII\", \"I\", \"II\", \"III\", \"IV\", \"V\", \"VI\", \"VII\", \"VIII\", \"IX\", \"X\", \"XI\"],          },          \"radialaxis\": {\"angle\": 90, \"visible\": False, \"range\": [0, 12]},      },      \"showlegend\": False,  }    # Options to be used for all three traces  base_opts = {\"fill\": \"toself\"}  # Specific for hours  hours_opts = dict(base_opts)  hours_opts[\"fillcolor\"] = \"#FF0000\"  # Specific for minutes  minutes_opts = dict(base_opts)  minutes_opts[\"fillcolor\"] = \"#00FF00\"  # Specific for seconds  seconds_opts = dict(base_opts)  seconds_opts[\"fillcolor\"] = \"#0000FF\"    # Store all the chart control properties in a single object  properties = {      # Don't show data point markers      \"mode\": \"lines\",      # Data for the hours      \"theta[1]\": \"0/a\",      \"r[1]\": \"0/r\",      # Data for the minutes      \"theta[2]\": \"1/a\",      \"r[2]\": \"1/r\",      # Data for the seconds      \"theta[3]\": \"2/a\",      \"r[3]\": \"2/r\",      # Options for the three traces      \"options[1]\": hours_opts,      \"options[2]\": minutes_opts,      \"options[3]\": seconds_opts,      \"line\": {\"color\": \"black\"},      \"layout\": layout,  }      # Update time on every refresh  def on_navigate(state, page):      state.data = generate_hand_shapes()      return page      page = \"\"\"  # Polar - Tick texts    <|{data}|chart|type=scatterpolar|properties={properties}|>  \"\"\"  Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {\"Types\": [\"Visits\", \"Downloads\", \"Prospects\", \"Invoiced\", \"Closed\"], \"Visits\": [13873, 10533, 5443, 2703, 908]}    layout = {      # Stack the areas      \"funnelmode\": \"stack\",      # Hide the legend      \"showlegend\": False,  }    page = \"\"\"  # Funnel - Area    <|{data}|chart|type=funnelarea|values=Visits|text=Types|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import pandas  from taipy.gui import Gui    # Source https://en.wikipedia.org/wiki/List_of_United_States_presidential_elections_by_popular_vote_margin  percentages = [      (1852, 50.83),      (1856, 45.29),      (1860, 39.65),      (1864, 55.03),      (1868, 52.66),      (1872, 55.58),      (1876, 47.92),      (1880, 48.31),      (1884, 48.85),      (1888, 47.80),      (1892, 46.02),      (1896.0, 51.02),      (1900, 51.64),      (1904, 56.42),      (1908, 51.57),      (1912, 41.84),      (1916, 49.24),      (1920, 60.32),      (1924, 54.04),      (1928, 58.21),  ]    # Lost percentage = 100-Won percentage  full = [(t[0], t[1], 100 - t[1]) for t in percentages]    data = pandas.DataFrame(full, columns=[\"Year\", \"Won\", \"Lost\"])    layout = {\"barmode\": \"stack\"}    page = \"\"\"  # Bar - Stacked    <|{data}|chart|type=bar|x=Year|y[1]=Won|y[2]=Lost|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import numpy  import pandas  from taipy.gui import Gui    # Generate a random value for every hour on a given day  data = {\"Date\": pandas.date_range(\"2023-01-04\", periods=24, freq=\"H\"), \"Value\": pandas.Series(numpy.random.randn(24))}    page = \"\"\"  # Basics - Timeline    <|{data}|chart|x=Date|y=Value|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    from taipy.gui import Gui    # Data set made of two series of random numbers  data = [{\"x\": [random.random() + 1 for i in range(100)]}, {\"x\": [random.random() + 1.1 for i in range(100)]}]    options = [      # First data set displayed as semi-transparent, green bars      {\"opacity\": 0.5, \"marker\": {\"color\": \"green\"}},      # Second data set displayed as semi-transparent, gray bars      {\"opacity\": 0.5, \"marker\": {\"color\": \"#888\"}},  ]    layout = {      # Overlay the two histograms      \"barmode\": \"overlay\",      # Hide the legend      \"showlegend\": False,  }    page = \"\"\"  # Histogram - Overlay    <|{data}|chart|type=histogram|options={options}|layout={layout}|>  \"\"\"  Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"Day\": [\"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\"],      \"Items\": [32, 25, 86, 60, 70],      \"Price\": [80, 50, 140, 10, 70],  }    options = [      # For items      {\"fill\": \"tozeroy\"},      # For price      # Using \"tonexty\" not to cover the first trace      {\"fill\": \"tonexty\"},  ]    page = \"\"\"  # Filled Area - Overlay    <|{data}|chart|mode=none|x=Day|y[1]=Items|y[2]=Price|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # x values are [-10..10]  x_range = range(-10, 11)    # The data set holds the _x_ series and two distinct series for _y_  data = {      \"x\": x_range,      # y1 = x*x      \"y1\": [x * x for x in x_range],      # y2 = 100-x*x      \"y2\": [100 - x * x for x in x_range],  }    page = \"\"\"  # Basics - Multiple traces    <|{data}|chart|x=x|y[1]=y1|y[2]=y2|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  # Two data sets as a bar chart  import pandas  from taipy.gui import Gui    # Source https://en.wikipedia.org/wiki/List_of_United_States_presidential_elections_by_popular_vote_margin  percentages = [      (1852, 50.83),      (1856, 45.29),      (1860, 39.65),      (1864, 55.03),      (1868, 52.66),      (1872, 55.58),      (1876, 47.92),      (1880, 48.31),      (1884, 48.85),      (1888, 47.80),      (1892, 46.02),      (1896.0, 51.02),      (1900, 51.64),      (1904, 56.42),      (1908, 51.57),      (1912, 41.84),      (1916, 49.24),      (1920, 60.32),      (1924, 54.04),      (1928, 58.21),  ]  data = pandas.DataFrame(percentages, columns=[\"Year\", \"Won\"])  lost = [100 - t[1] for t in percentages]  data[\"Lost\"] = lost    page = \"\"\"  # Bar - Multiple    <|{data}|chart|type=bar|x=Year|y[1]=Won|y[2]=Lost|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # You may need to install the yfinance package as well.  # -----------------------------------------------------------------------------------------  import yfinance  from taipy import Gui    # Extraction of a month of stock data for AAPL using the  # yfinance package (see https://pypi.org/project/yfinance/).  ticker = yfinance.Ticker(\"AAPL\")  # The returned value is a Pandas DataFrame.  stock = ticker.history(interval=\"1d\", start=\"2018-08-01\", end=\"2018-08-31\")  # Copy the DataFrame's index to a new column  stock[\"Date\"] = stock.index    page = \"\"\"  # Candlestick - Simple    <|{stock}|chart|type=candlestick|x=Date|open=Open|close=Close|low=Low|high=High|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    import numpy  from taipy.gui import Gui    # x = [0..20]  x = list(range(0, 21))    data = {      \"x\": x,      # A list of random values within [1, 10]      \"y\": [random.uniform(1, 10) for _ in x],  }    layout = {      # Force the Box select tool      \"dragmode\": \"select\",      # Remove all margins around the plot      \"margin\": {\"l\": 0, \"r\": 0, \"b\": 0, \"t\": 0},  }    config = {      # Hide Plotly's mode bar      \"displayModeBar\": False  }    selected_indices = []    mean_value = 0.0      def on_change(state, var, val):      if var == \"selected_indices\":          state.mean_value = numpy.mean([data[\"y\"][idx] for idx in val]) if len(val) else 0      page = \"\"\"  # Advanced - Selection    ## Mean of <|{len(selected_indices)}|raw|> selected points: <|{mean_value}|format=%.2f|raw|>    <|{data}|chart|selected={selected_indices}|layout={layout}|plot_config={config}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import math  import random    from taipy.gui import Gui    # Number of samples  max_x = 20  # x values: [0..max_x-1]  x = range(0, max_x)  # Generate random sampling error margins  error_ranges = [random.uniform(0, 5) for _ in x]  # Compute a perfect sine wave  perfect_y = [10 * math.sin(4 * math.pi * i / max_x) for i in x]  # Compute a sine wave impacted by the sampling error  # The error is between \u00b1error_ranges[x]/2  y = [perfect_y[i] + random.uniform(-error_ranges[i] / 2, error_ranges[i] / 2) for i in x]    # The chart data is made of the three series  data = {      \"x\": x,      \"y1\": y,      \"y2\": perfect_y,  }    options = {      # Create the error bar information:      \"error_y\": {\"type\": \"data\", \"array\": error_ranges}  }    page = \"\"\"  # Error bars - Simple    <|{data}|chart|x=x|y[1]=y1|y[2]=y2|options[1]={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"Day\": [\"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\"],      \"Items\": [32, 25, 86, 60, 70],  }    options = {      # Fill to x axis      \"fill\": \"tozeroy\"  }    page = \"\"\"  # Filled Area - Simple    <|{data}|chart|x=Day|y=Items|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import datetime    import dateutil.relativedelta  from taipy.gui import Gui    # Data is collected from January 1st, 2010, every month  start_date = datetime.datetime(year=2010, month=1, day=1)  period = dateutil.relativedelta.relativedelta(months=1)    # Data  # All arrays have the same size (the number of months to track)  prices = {      # Data for apples      \"apples\": [2.48, 2.47, 2.5, 2.47, 2.46, 2.38, 2.31, 2.25, 2.39, 2.41, 2.59, 2.61],      \"apples_low\": [1.58, 1.58, 1.59, 1.64, 1.79, 1.54, 1.53, 1.61, 1.65, 2.02, 1.92, 1.54],      \"apples_high\": [3.38, 3.32, 2.63, 2.82, 2.58, 2.53, 3.27, 3.15, 3.44, 3.42, 3.08, 2.86],      \"bananas\": [2.94, 2.50, 2.39, 2.77, 2.43, 2.32, 2.37, 1.90, 2.31, 2.71, 3.38, 1.92],      \"bananas_low\": [2.12, 1.90, 1.69, 2.44, 1.58, 1.81, 1.44, 1.00, 1.59, 1.74, 2.78, 0.96],      \"bananas_high\": [3.32, 2.70, 3.12, 3.25, 3.00, 2.63, 2.54, 2.37, 2.97, 3.69, 4.36, 2.95],      \"cherries\": [6.18, None, None, None, 3.69, 2.46, 2.31, 2.57, None, None, 6.50, 4.38],      \"cherries_high\": [7.00, None, None, None, 8.50, 6.27, 5.61, 4.36, None, None, 8.00, 7.23],      \"cherries_low\": [3.55, None, None, None, 1.20, 0.87, 1.08, 1.50, None, None, 5.00, 4.20],  }    # Create monthly time series  months = [start_date + n * period for n in range(0, len(prices[\"apples\"]))]    data = [      # Raw data      {\"Months\": months, \"apples\": prices[\"apples\"], \"bananas\": prices[\"bananas\"], \"cherries\": prices[\"cherries\"]},      # Range data (twice as many values)      {          \"Months2\": months + list(reversed(months)),          \"apples\": prices[\"apples_high\"] + list(reversed(prices[\"apples_low\"])),          \"bananas\": prices[\"bananas_high\"] + list(reversed(prices[\"bananas_low\"])),          \"cherries\": prices[\"cherries_high\"] + list(reversed(prices[\"cherries_low\"])),      },  ]    properties = {      # First trace: reference for Apples      \"x[1]\": \"0/Months\",      \"y[1]\": \"0/apples\",      \"color[1]\": \"rgb(0,200,80)\",      #     Hide line      \"mode[1]\": \"markers\",      #     Show in the legend      \"name[1]\": \"Apples\",      # Second trace: reference for Bananas      \"x[2]\": \"0/Months\",      \"y[2]\": \"0/bananas\",      \"color[2]\": \"rgb(0,100,240)\",      #     Hide line      \"mode[2]\": \"markers\",      #     Show in the legend      \"name[2]\": \"Bananas\",      # Third trace: reference for Cherries      \"x[3]\": \"0/Months\",      \"y[3]\": \"0/cherries\",      \"color[3]\": \"rgb(240,60,60)\",      #     Hide line      \"mode[3]\": \"markers\",      #     Show in the legend      \"name[3]\": \"Cherries\",      # Fourth trace: range for Apples      \"x[4]\": \"1/Months2\",      \"y[4]\": \"1/apples\",      \"options[4]\": {          \"fill\": \"tozerox\",          \"showlegend\": False,          \"fillcolor\": \"rgba(0,100,80,0.4)\",      },      #      No surrounding stroke      \"color[4]\": \"transparent\",      # Fifth trace: range for Bananas      \"x[5]\": \"1/Months2\",      \"y[5]\": \"1/bananas\",      \"options[5]\": {\"fill\": \"tozerox\", \"showlegend\": False, \"fillcolor\": \"rgba(0,180,250,0.4)\"},      #      No surrounding stroke      \"color[5]\": \"transparent\",      # Sixth trace: range for Cherries      \"x[6]\": \"1/Months2\",      \"y[6]\": \"1/cherries\",      \"options[6]\": {          \"fill\": \"tozerox\",          \"showlegend\": False,          \"fillcolor\": \"rgba(230,100,120,0.4)\",      },      #      No surrounding stroke      \"color[6]\": \"transparent\",  }    page = \"\"\"  # Continuous Error - Multiple traces    <|{data}|chart|properties={properties}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    from taipy.gui import Gui    # Number of samples  n_samples = 10  # y values: [0..n_samples-1]  y = range(0, n_samples)    data = {      # The x series is made of random numbers between 1 and 10      \"x\": [random.uniform(1, 10) for i in y],      \"y\": y,  }    options = {      \"error_x\": {          \"type\": \"data\",          # Allows for a 'plus' and a 'minus' error data          \"symmetric\": False,          # The 'plus' error data is a series of random numbers          \"array\": [random.uniform(0, 5) for i in y],          # The 'minus' error data is a series of random numbers          \"arrayminus\": [random.uniform(0, 2) for i in y],          # Color of the error bar          \"color\": \"red\",      }  }    page = \"\"\"  # Error bars - Asymmetric    <|{data}|chart|type=bar|x=x|y=y|orientation=h|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import math    from taipy.gui import Gui    # One data point for each degree  theta = range(0, 360)      # Parametric equation that draws a shape (source Wolfram Mathworld)  def draw_heart(angle):      a = math.radians(angle)      sa = math.sin(a)      return 2 - 2 * sa + sa * (math.sqrt(math.fabs(math.cos(a))) / (sa + 1.4))      data = {      # Create the heart shape      \"r\": [draw_heart(angle) for angle in theta],      \"theta\": theta,  }    page = \"\"\"  # Polar - Simple    <|{data}|chart|type=scatterpolar|mode=lines|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # List of countries, used as labels in the pie charts  countries = [\"US\", \"China\", \"European Union\", \"Russian Federation\", \"Brazil\", \"India\", \"Rest of World\"]    data = [      {          # Values for GHG Emissions          \"values\": [16, 15, 12, 6, 5, 4, 42],          \"labels\": countries,      },      {          # Values for CO2 Emissions          \"values\": [27, 11, 25, 8, 1, 3, 25],          \"labels\": countries,      },  ]    options = [      # First pie chart      {          # Show label value on hover          \"hoverinfo\": \"label\",          # Leave a hole in the middle of the chart          \"hole\": 0.4,          # Place the trace on the left side          \"domain\": {\"column\": 0},      },      # Second pie chart      {          # Show label value on hover          \"hoverinfo\": \"label\",          # Leave a hole in the middle of the chart          \"hole\": 0.4,          # Place the trace on the right side          \"domain\": {\"column\": 1},      },  ]    layout = {      # Chart title      \"title\": \"Global Emissions 1990-2011\",      # Show traces in a 1x2 grid      \"grid\": {\"rows\": 1, \"columns\": 2},      \"annotations\": [          # Annotation for the first trace          {              \"text\": \"GHG\",              \"font\": {\"size\": 20},              # Hide annotation arrow              \"showarrow\": False,              # Move to the center of the trace              \"x\": 0.18,              \"y\": 0.5,          },          # Annotation for the second trace          {              \"text\": \"CO2\",              \"font\": {\"size\": 20},              \"showarrow\": False,              # Move to the center of the trace              \"x\": 0.81,              \"y\": 0.5,          },      ],      \"showlegend\": False,  }    page = \"\"\"  # Pie - Multiple    <|{data}|chart|type=pie|x[1]=0/values|x[2]=1/values|options={options}|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # The first data set uses the x interval [-10..10],  # with one point at every other unit  x1_range = [x * 2 for x in range(-5, 6)]    # The second data set uses the x interval [-4..4],  # with ten point between every unit  x2_range = [x / 10 for x in range(-40, 41)]    # Definition of the two data sets  data = [      # Coarse data set      {\"x\": x1_range, \"Coarse\": [x * x for x in x1_range]},      # Fine data set      {\"x\": x2_range, \"Fine\": [x * x for x in x2_range]},  ]    page = \"\"\"  # Advanced - Unbalanced data sets    <|{data}|chart|x[1]=0/x|y[1]=0/Coarse|x[2]=1/x|y[2]=1/Fine|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Flight start and end locations  data = {      # Hartsfield-Jackson Atlanta International Airport      # to      # A\u00e9roport de Paris-Charles de Gaulle      \"lat\": [33.64, 49.01],      \"lon\": [-84.44, 2.55],  }    layout = {      # Chart title      \"title\": \"ATL to CDG\",      # Hide legend      \"showlegend\": False,      # Focus on relevant area      \"geo\": {          \"resolution\": 50,          \"showland\": True,          \"showocean\": True,          \"landcolor\": \"4a4\",          \"oceancolor\": \"77d\",          \"lataxis\": {\"range\": [20, 60]},          \"lonaxis\": {\"range\": [-100, 20]},      },  }    # Flight displayed as a thick, red plot  line = {\"width\": 5, \"color\": \"red\"}    page = \"\"\"  # Maps - Simple    <|{data}|chart|type=scattergeo|mode=lines|lat=lat|lon=lon|line={line}|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    from taipy.gui import Gui    # Random data set  data = {\"Count\": [random.random() for i in range(100)]}    page = \"\"\"  # Histograms - Horizontal    <|{data}|chart|type=histogram|y=Count|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = [      {          \"x\": [1, 2, 3, 4],          \"y\": [10, 11, 12, 13],      },      {          \"x\": [1, 2, 3, 4],          \"y\": [11, 12, 13, 14],      },      {          \"x\": [1, 2, 3, 4],          \"y\": [12, 13, 14, 15],      },  ]    options = [      # First data set is represented by increasingly large      # disks, getting more and more opaque      {\"marker\": {\"color\": \"red\", \"size\": [12, 22, 32, 42], \"opacity\": [0.2, 0.5, 0.7, 1]}},      # Second data set is represented with a different symbol      # for each data point      {          \"marker\": {\"color\": \"blue\", \"size\": 18, \"symbol\": [\"circle\", \"square\", \"diamond\", \"cross\"]},      },      # Third data set is represented with green disks surrounded      # by a red circle that becomes thicker and thicker      {          \"marker\": {\"color\": \"green\", \"size\": 20, \"line\": {\"color\": \"red\", \"width\": [2, 4, 6, 8]}},      },  ]    markers = [      # First data set is represented by increasingly large      # disks, getting more and more opaque      {\"color\": \"red\", \"size\": [12, 22, 32, 42], \"opacity\": [0.2, 0.5, 0.7, 1]},      # Second data set is represented with a different symbol      # for each data point      {\"color\": \"blue\", \"size\": 18, \"symbol\": [\"circle\", \"square\", \"diamond\", \"cross\"]},      # Third data set is represented with green disks surrounded      # by a red circle that becomes thicker and thicker      {\"color\": \"green\", \"size\": 20, \"line\": {\"color\": \"red\", \"width\": [2, 4, 6, 8]}},  ]    layout = {      # Hide the chart legend      \"showlegend\": False,      # Remove all ticks from the x axis      \"xaxis\": {\"showticklabels\": False},      # Remove all ticks from the y axis      \"yaxis\": {\"showticklabels\": False},  }    page = \"\"\"  ## Scatter - Customize markers    <|{data}|chart|mode=markers|layout={layout}|marker={markers}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"Month\": [\"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\", \"Jul\", \"Aug\", \"Sep\", \"Oct\", \"Nov\", \"Dec\"],      \"Milk\": [80, 85, 95, 120, 140, 130, 145, 150, 120, 100, 90, 110],      \"Bread\": [100, 90, 85, 90, 100, 110, 105, 95, 100, 110, 120, 125],      \"Apples\": [50, 65, 70, 65, 70, 75, 85, 70, 60, 65, 70, 80],  }    # Name of the three sets to trace  items = [\"Milk\", \"Bread\", \"Apples\"]    options = {      # Group all traces in the same stack group      \"stackgroup\": \"first_group\"  }    page = \"\"\"  # Filled Area - Stacked    <|{data}|chart|mode=none|x=Month|y={items}|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Data set  data = [      {          # The quarterly periods are grouped by year          \"Period\": [[\"Carry\", \"Q1\", \"Q2\", \"Q3\", \"Q4\", \"Current\"], [\"N-1\", \"N\", \"N\", \"N\", \"N\", \"N+1\"]]      },      {          \"Cash Flow\": [25, -17, 12, 18, -8, None],          \"Measure\": [\"absolute\", \"relative\", \"relative\", \"relative\", \"relative\", \"total\"],      },  ]    page = \"\"\"  # Waterfall - Period levels    <|{data}|chart|type=waterfall|x=0/Period|y=1/Cash Flow|measure=1/Measure|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Major countries and their surface (in km2), for every continent  # Source: https://en.wikipedia.org/wiki/List_of_countries_and_dependencies_by_area  continents = {      \"Africa\": [          {\"name\": \"Algeria\", \"surface\": 2381741},          {\"name\": \"Dem. Rep. Congo\", \"surface\": 2344858},          {\"name\": \"Sudan\", \"surface\": 1886068},          {\"name\": \"Libya\", \"surface\": 1759540},          {\"name\": \"Chad\", \"surface\": 1284000},      ],      \"Asia\": [          {\"name\": \"Russia-Asia\", \"surface\": 17098246},          {\"name\": \"China\", \"surface\": 9596961},          {\"name\": \"India\", \"surface\": 3287263},          {\"name\": \"Kazakhstan\", \"surface\": 2724900},          {\"name\": \"Saudi Arabia\", \"surface\": 2149690},      ],      \"Europe\": [          {\"name\": \"Russia-Eur\", \"surface\": 3972400},          {\"name\": \"Ukraine\", \"surface\": 603628},          {\"name\": \"France\", \"surface\": 551695},          {\"name\": \"Spain\", \"surface\": 498980},          {\"name\": \"Sweden\", \"surface\": 450295},      ],      \"Americas\": [          {\"name\": \"Canada\", \"surface\": 9984670},          {\"name\": \"U.S.A.\", \"surface\": 9833517},          {\"name\": \"Brazil\", \"surface\": 8515767},          {\"name\": \"Argentina\", \"surface\": 2780400},          {\"name\": \"Mexico\", \"surface\": 1964375},      ],      \"Oceania\": [          {\"name\": \"Australia\", \"surface\": 7692024},          {\"name\": \"Papua New Guinea\", \"surface\": 462840},          {\"name\": \"New Zealand\", \"surface\": 270467},          {\"name\": \"Solomon Islands\", \"surface\": 28896},          {\"name\": \"Fiji\", \"surface\": 18274},      ],      \"Antarctica\": [{\"name\": \"Whole\", \"surface\": 14200000}],  }    name = []  surface = []  continent = []    for continent_name, countries in continents.items():      # Create continent in root rectangle      name.append(continent_name)      surface.append(0)      continent.append(\"\")      # Create countries in that continent rectangle      for country in countries:          name.append(country[\"name\"])          surface.append(country[\"surface\"])          continent.append(continent_name)    data = {\"names\": name, \"surfaces\": surface, \"continent\": continent}    page = \"\"\"  # TreeMap - Hierarchical values    <|{data}|chart|type=treemap|labels=names|values=surfaces|parents=continent|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import datetime    from taipy.gui import Gui    # Retrieved history:  # (Open, Close, Low, High)  stock_history = [      (311.05, 311.00, 310.75, 311.33),      (308.53, 308.31, 307.72, 309.00),      (307.35, 306.24, 306.12, 307.46),      (306.35, 304.90, 304.34, 310.10),      (304.90, 302.99, 302.27, 307.00),      (303.03, 301.66, 301.20, 303.25),      (301.61, 299.58, 299.50, 301.89),      (299.58, 297.95, 297.80, 300.06),      (297.95, 299.03, 297.14, 299.67),      (299.03, 301.87, 296.71, 301.89),      (301.89, 299.40, 298.73, 302.93),      (299.50, 299.35, 298.83, 299.50),      (299.35, 299.20, 299.19, 299.68),      (299.42, 300.50, 299.42, 300.50),      (300.70, 300.65, 300.32, 300.75),      (300.65, 299.91, 299.91, 300.76),  ]  start_date = datetime.datetime(year=2022, month=10, day=21)  period = datetime.timedelta(seconds=4 * 60 * 60)  # 4 hours    data = {      # Compute date series      \"Date\": [start_date + n * period for n in range(0, len(stock_history))],      # Extract open values      \"Open\": [v[0] for v in stock_history],      # Extract close values      \"Close\": [v[1] for v in stock_history],      # Extract low values      \"Low\": [v[2] for v in stock_history],      # Extract high values      \"High\": [v[3] for v in stock_history],  }    md = \"\"\"  # Candlestick - Timeline    <|{data}|chart|type=candlestick|x=Date|open=Open|close=Close|low=Low|high=High|>  \"\"\"    Gui(md).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"John_us\": [500, 450, 340, 230, 220, 110],      \"John_eu\": [600, 500, 400, 300, 200, 100],      \"Robert_us\": [510, 480, 440, 330, 220, 100],      \"Robert_eu\": [360, 250, 240, 130, 120, 60],  }    # Values for each trace  values = [\"John_us\", \"John_eu\", \"Robert_us\", \"Robert_eu\"]    options = [      # For John/US      {          \"scalegroup\": \"first\",          \"textinfo\": \"value\",          \"title\": {              # \"position\": \"top\",              \"text\": \"John in the U.S.\"          },          # Lower-left corner          \"domain\": {\"x\": [0, 0.5], \"y\": [0, 0.5]},      },      # For John/EU      {          \"scalegroup\": \"first\",          \"textinfo\": \"value\",          \"title\": {              # \"position\": \"top\",              \"text\": \"John in the E.U.\"          },          # Upper-left corner          \"domain\": {\"x\": [0, 0.5], \"y\": [0.55, 1]},      },      # For Robert/US      {          \"scalegroup\": \"second\",          \"textinfo\": \"value\",          \"title\": {              # \"position\": \"top\",              \"text\": \"Robert in the U.S.\"          },          # Lower-right corner          \"domain\": {\"x\": [0.51, 1], \"y\": [0, 0.5]},      },      # For Robert/EU      {          \"scalegroup\": \"second\",          \"textinfo\": \"value\",          \"title\": {              # \"position\": \"top\",              \"text\": \"Robert in the E.U.\"          },          # Upper-right corner          \"domain\": {\"x\": [0.51, 1], \"y\": [0.51, 1]},      },  ]    layout = {      \"title\": \"Sales per Salesman per Region\",      \"showlegend\": False,      # Draw frames around each trace      \"shapes\": [          {\"x0\": 0, \"x1\": 0.5, \"y0\": 0, \"y1\": 0.5},          {\"x0\": 0, \"x1\": 0.5, \"y0\": 0.52, \"y1\": 1},          {\"x0\": 0.52, \"x1\": 1, \"y0\": 0, \"y1\": 0.5},          {\"x0\": 0.52, \"x1\": 1, \"y0\": 0.52, \"y1\": 1},      ],  }    page = \"\"\"  # Funnel Area - Multiple Charts    <|{data}|chart|type=funnelarea|values={values}|options={options}|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import math    from taipy.gui import Gui    # One data point for each degree  theta = range(0, 360)      # Parametric equation that draws a shape (source Wolfram Mathworld)  def draw_heart(angle):      a = math.radians(angle)      sa = math.sin(a)      return 2 - 2 * sa + sa * (math.sqrt(math.fabs(math.cos(a))) / (sa + 1.4))      data = {      # Create the heart shape      \"r\": [draw_heart(angle) for angle in theta],      \"theta\": theta,  }    options = {\"fill\": \"toself\"}    layout = {      # Hide the legend      \"showlegend\": False,      \"polar\": {          # Hide the angular axis          \"angularaxis\": {\"visible\": False},          # Hide the radial axis          \"radialaxis\": {\"visible\": False},      },  }    page = \"\"\"  # Polar - Area    <|{data}|chart|type=scatterpolar|mode=none|layout={layout}|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Partial family tree of the British House of Windsor  # Source: https://en.wikipedia.org/wiki/Family_tree_of_the_British_royal_family  tree = {      \"name\": [          \"Queen Victoria\",          \"Princess Victoria\",          \"Edward VII\",          \"Alice\",          \"Alfred\",          \"Wilhelm II\",          \"Albert Victor\",          \"George V\",          \"Louise\",          \"Ernest Louis\",          \"Alfred (2)\",          \"Marie\",          \"Victoria Melita\",          \"Edward VIII\",          \"George VI\",          \"Mary\",          \"Elizabeth II\",          \"Margaret\",          \"Charles III\",          \"Anne\",          \"Andrew\",      ],      \"parent\": [          \"\",          \"Queen Victoria\",          \"Queen Victoria\",          \"Queen Victoria\",          \"Queen Victoria\",          \"Princess Victoria\",          \"Edward VII\",          \"Edward VII\",          \"Edward VII\",          \"Alice\",          \"Alfred\",          \"Alfred\",          \"Alfred\",          \"George V\",          \"George V\",          \"George V\",          \"George VI\",          \"George VI\",          \"Elizabeth II\",          \"Elizabeth II\",          \"Elizabeth II\",      ],  }    page = \"\"\"  # TreeMap - Hierarchical    <|{tree}|chart|type=treemap|labels=name|parents=parent|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # You may need to install the scikit-learn package as well.  # -----------------------------------------------------------------------------------------  import numpy as np  import pandas as pd  from sklearn.datasets import make_classification  from taipy.gui import Gui    # Let scikit-learn generate a random 2-class classification problem  n_samples = 100  features, label = make_classification(n_samples=n_samples, n_features=2, n_informative=2, n_redundant=0)    random_data = pd.DataFrame({\"x\": features[:, 0], \"y\": features[:, 1], \"label\": label})    data_x = random_data[\"x\"]  class_A = [random_data.loc[i, \"y\"] if random_data.loc[i, \"label\"] == 0 else np.nan for i in range(n_samples)]  class_B = [random_data.loc[i, \"y\"] if random_data.loc[i, \"label\"] == 1 else np.nan for i in range(n_samples)]    data = {\"x\": random_data[\"x\"], \"Class A\": class_A, \"Class B\": class_B}  marker_A = {\"symbol\": \"circle-open\", \"size\": 16}  marker_B = {\"symbol\": \"triangle-up-dot\", \"size\": 20, \"opacity\": 0.7}  page = \"\"\"  # Scatter - Styling    <|{data}|chart|mode=markers|x=x|y[1]=Class A|y[2]=Class B|width=60%|marker[1]={marker_A}|marker[2]={marker_B}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"Temperatures\": [          [17.2, 27.4, 28.6, 21.5],          [5.6, 15.1, 20.2, 8.1],          [26.6, 22.8, 21.8, 24.0],          [22.3, 15.5, 13.4, 19.6],      ],      \"Cities\": [\"Hanoi\", \"Paris\", \"Rio\", \"Sydney\"],      \"Seasons\": [\"Winter\", \"Spring\", \"Summer\", \"Autumn\"],  }    options = {\"colorscale\": \"Portland\"}    page = \"\"\"  # Heatmap - Colorscale    <|{data}|chart|type=heatmap|z=Temperatures|x=Seasons|y=Cities|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    layout = {      \"xaxis\": {          # Force the title of the x axis          \"title\": \"Values for x\"      }  }    page = \"\"\"  # Basics - Title    <|{[x*x for x in range(0, 11)]}|chart|title=Plotting x squared|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Data set: the first 10 elements of the Fibonacci sequence  n_numbers = 10  fibonacci = [0, 1]  for i in range(2, n_numbers):      fibonacci.append(fibonacci[i - 1] + fibonacci[i - 2])    data = {\"index\": [i for i in range(1, n_numbers + 1)], \"fibonacci\": fibonacci}    page = \"\"\"  # TreeMap - Simple    <|{data}|chart|type=treemap|labels=index|values=fibonacci|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy import Gui    # The chart control's data is defined as inline  # code.  page = \"\"\"  # Basics - Simple line    <|{[x*x for x in range(0, 11)]}|chart|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    from taipy import Gui    # Random data set  data = [random.gauss(0, 5) for i in range(1000)]    page = \"\"\"  # Histogram - Simple    <|{data}|chart|type=histogram|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import pandas  from taipy.gui import Gui    # Source https://en.wikipedia.org/wiki/List_of_United_States_presidential_elections_by_popular_vote_margin  percentages = [      (1852, 50.83),      (1856, 45.29),      (1860, 39.65),      (1864, 55.03),      (1868, 52.66),      (1872, 55.58),      (1876, 47.92),      (1880, 48.31),      (1884, 48.85),      (1888, 47.80),      (1892, 46.02),      (1896.0, 51.02),      (1900, 51.64),      (1904, 56.42),      (1908, 51.57),      (1912, 41.84),      (1916, 49.24),      (1920, 60.32),      (1924, 54.04),      (1928, 58.21),      (1932, 57.41),      (1936, 60.80),      (1940, 54.74),      (1944, 53.39),      (1948, 49.55),      (1952, 55.18),      (1956, 57.37),      (1960, 49.72),      (1964, 61.05),      (1968, 43.42),      (1972, 60.67),      (1976, 50.08),      (1980, 50.75),      (1984, 58.77),      (1988, 53.37),      (1992, 43.01),      (1996, 49.23),      (2000, 47.87),      (2004, 50.73),      (2008, 52.93),      (2012, 51.06),      (2016, 46.09),      (2020, 51.31),  ]  data = pandas.DataFrame(percentages, columns=[\"Year\", \"%\"])    page = \"\"\"  # Bar - Simple    <|{data}|chart|type=bar|x=Year|y=%|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    from taipy.gui import Gui    # Random set of 100 samples  samples = {\"x\": [random.gauss() for i in range(100)]}    # Use the same data for both traces  data = [samples, samples]    options = [      # First data set displayed as green-ish, and 5 bins      {\"marker\": {\"color\": \"#4A4\"}, \"nbinsx\": 5},      # Second data set displayed as red-ish, and 25 bins      {\"marker\": {\"color\": \"#A33\"}, \"nbinsx\": 25},  ]    layout = {      # Overlay the two histograms      \"barmode\": \"overlay\",      # Hide the legend      \"showlegend\": False,  }    page = \"\"\"  # Histogram - NBins    <|{data}|chart|type=histogram|options={options}|layout={layout}|>  \"\"\"  Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Data set  data = {\"Opps\": [\"Hot leads\", \"Doc sent\", \"Quote\", \"Closed Won\"], \"Visits\": [316, 238, 125, 83]}    page = \"\"\"  # Funnel Chart - Simple    <|{data}|chart|type=funnel|x=Visits|y=Opps|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = [      {          \"Temperatures\": [              [17.2, 27.4, 28.6, 21.5],              [5.6, 15.1, 20.2, 8.1],              [26.6, 22.8, 21.8, 24.0],              [22.3, 15.5, 13.4, 19.6],              [3.9, 18.9, 25.7, 9.8],          ],          \"Cities\": [\"Hanoi\", \"Paris\", \"Rio\", \"Sydney\", \"Washington\"],      },      {\"Seasons\": [\"Winter\", \"Spring\", \"Summer\", \"Autumn\"]},  ]    page = \"\"\"  # Heatmap - Unbalanced    <|{data}|chart|type=heatmap|z=0/Temperatures|x=1/Seasons|y=0/Cities|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Sample small plot definition  trace = {      \"r\": [1, 2, 3, 4, 1],      \"theta\": [0, 40, 80, 120, 160],  }    # The same data is used in both traces  data = [trace, trace]    # Naming the subplot is mandatory to get them both in  # the same chart  options = [      {          \"subplot\": \"polar\",      },      {\"subplot\": \"polar2\"},  ]    layout = {      # Hide the legend      \"showlegend\": False,      # Restrict the angular values for second trace      \"polar2\": {\"sector\": [30, 130]},  }    md = \"\"\"  # Polar - Sectors    <|{data}|chart|type=scatterpolar|layout={layout}|options={options}|>  \"\"\"    Gui(md).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # You may need to install the yfinance package as well.  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"x\": [1, 2, 3],      \"y\": [1, 2, 3],      \"Colors\": [\"blue\", \"green\", \"red\"],      \"Sizes\": [20, 40, 30],      \"Opacities\": [1, 0.4, 1],  }    marker = {\"color\": \"Colors\", \"size\": \"Sizes\", \"opacity\": \"Opacities\"}    page = \"\"\"  # Bubble - Simple    <|{data}|chart|mode=markers|x=x|y=y|marker={marker}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Source: www.statista.com (Most used programming languages in 2022)  data = {      # List of programming languages      \"Language\": [\"JavaScript\", \"HTML/CSS\", \"SQL\", \"Python\", \"Typescript\", \"Java\", \"Bash/Shell\"],      # Percentage of usage, per language      \"%\": [65.36, 55.08, 49.43, 48.07, 34.83, 33.27, 29.07],  }    # Close the shape for a nice-looking stroke  # If the first point is *not* appended to the end of the list,  # then the shape does not look as it is closed.  data[\"%\"].append(data[\"%\"][0])  data[\"Language\"].append(data[\"Language\"][0])    layout = {      \"polar\": {          \"radialaxis\": {              # Force the radial range to 0-100              \"range\": [0, 100],          }      },      # Hide legend      \"showlegend\": False,  }    options = {      # Fill the trace      \"fill\": \"toself\"  }    md = \"\"\"  # Radar - Simple    <|{data}|chart|type=scatterpolar|r=%|theta=Language|options={options}|layout={layout}|>  \"\"\"    Gui(md).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Initial data set. y = count_of(x)  samples = {\"x\": [\"Apples\", \"Apples\", \"Apples\", \"Oranges\", \"Bananas\", \"Oranges\"], \"y\": [5, 10, 3, 8, 5, 2]}    # Create a data set array to allow for two traces  data = [samples, samples]    # Gather those settings in a single dictionary  properties = {      # 'x' of the first trace is the 'x' data from the first element of data      \"x[1]\": \"0/x\",      # 'y' of the first trace is the 'y' data from the first element of data      \"y[1]\": \"0/y\",      # 'x' of the second trace is the 'x' data from the second element of data      \"x[2]\": \"1/x\",      # 'y' of the second trace is the 'y' data from the second element of data      \"y[2]\": \"1/y\",      # Data set colors      \"color\": [\"#cd5c5c\", \"#505070\"],      # Data set names (for the legend)      \"name\": [\"Count\", \"Sum\"],      # Configure the binning functions      \"options\": [          # First trace: count the bins          {\"histfunc\": \"count\"},          # Second trace: sum the bin occurences          {\"histfunc\": \"sum\"},      ],      # Set x axis name      \"layout\": {\"xaxis\": {\"title\": \"Fruit\"}},  }    page = \"\"\"  # Histogram - Binning function    <|{data}|chart|type=histogram|properties={properties}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Skill categories  skills = [\"HTML\", \"CSS\", \"Java\", \"Python\", \"PHP\", \"JavaScript\", \"Photoshop\"]  data = [      # Proportion of skills used for Backend development      {\"Backend\": [10, 10, 80, 70, 90, 30, 0], \"Skills\": skills},      # Proportion of skills used for Frontend development      {\"Frontend\": [90, 90, 0, 10, 20, 80, 60], \"Skills\": skills},  ]    # Append first elements to all arrays for a nice stroke  skills.append(skills[0])  data[0][\"Backend\"].append(data[0][\"Backend\"][0])  data[1][\"Frontend\"].append(data[1][\"Frontend\"][0])    layout = {      # Force the radial axis displayed range      \"polar\": {\"radialaxis\": {\"range\": [0, 100]}}  }    # Fill the trace  options = {\"fill\": \"toself\"}    # Reflected in the legend  names = [\"Backend\", \"Frontend\"]    # To shorten the chart control definition  r = [\"0/Backend\", \"1/Frontend\"]  theta = [\"0/Skills\", \"1/Skills\"]    page = \"\"\"  # Radar - Multiple    <|{data}|chart|type=scatterpolar|name={names}|r={r}|theta={theta}|options={options}|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # x values are [-10..10]  x_range = range(-10, 11)    # The data set holds the _x_ series and two distinct series for _y_  data = {      \"x\": x_range,      # y1 = x*x      \"y1\": [x * x for x in x_range],      # y2 = 2-x*x/50      \"y2\": [(100 - x * x) / 50 for x in x_range],  }    layout = {      \"yaxis2\": {          # Second axis overlays with the first y axis          \"overlaying\": \"y\",          # Place the second axis on the right          \"side\": \"right\",          # and give it a title          \"title\": \"Second y axis\",      },      \"legend\": {          # Place the legend above chart          \"yanchor\": \"bottom\"      },  }    page = \"\"\"  # Basics - Multiple axis    Shared axis:  <|{data}|chart|x=x|y[1]=y1|y[2]=y2|height=300px|>    With two axis:  <|{data}|chart|x=x|y[1]=y1|y[2]=y2|yaxis[2]=y2|layout={layout}|height=300px|>    \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Source https://www.fao.org/faostat/en/#data/SDGB  data = {      \"Country\": [          \"Rest of the world\",          \"Russian Federation\",          \"Brazil\",          \"Canada\",          \"United States of America\",          \"China\",          \"Australia\",          \"Democratic Republic of the Congo\",          \"Indonesia\",          \"Peru\",      ],      \"Area\": [1445674.66, 815312, 496620, 346928, 309795, 219978, 134005, 126155, 92133.2, 72330.4],  }    page = \"\"\"  # Pie - Simple    <|{data}|chart|type=pie|values=Area|label=Country|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # You may need to install the scikit-learn package as well.  # -----------------------------------------------------------------------------------------  from os.path import exists    from sklearn.datasets import make_regression  from sklearn.linear_model import LinearRegression  from taipy.gui import Gui    # Let scikit-learn generate a random regression problem  n_samples = 300  X, y, coef = make_regression(n_samples=n_samples, n_features=1, n_informative=1, n_targets=1, noise=25, coef=True)    model = LinearRegression().fit(X, y)    x_data = X.flatten()  y_data = y.flatten()  predict = model.predict(X)    data = {\"x\": x_data, \"y\": y_data, \"Regression\": predict}    page = \"\"\"  # Scatter - Regression    <|{data}|chart|x=x|y[1]=y|mode[1]=markers|y[2]=Regression|mode[2]=line|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"x\": [1, 2, 3],      \"y\": [1, 2, 3],      \"Texts\": [\"Blue<br>Small\", \"Green<br>Medium\", \"Red<br>Large\"],      \"Sizes\": [60, 80, 100],      \"Colors\": [          \"rgb(93, 164, 214)\",          \"rgb(44, 160, 101)\",          \"rgb(255, 65, 54)\",      ],  }    marker = {\"size\": \"Sizes\", \"color\": \"Colors\"}    page = \"\"\"  # Bubble - Hover text    <|{data}|chart|mode=markers|x=x|y=y|marker={marker}|text=Texts|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"Temperatures\": [          [17.2, 27.4, 28.6, 21.5],          [5.6, 15.1, 20.2, 8.1],          [26.6, 22.8, 21.8, 24.0],          [22.3, 15.5, 13.4, 19.6],      ],      \"Cities\": [\"Hanoi\", \"Paris\", \"Rio\", \"Sydney\"],      \"Seasons\": [\"Winter\", \"Spring\", \"Summer\", \"Autumn\"],  }    layout = {      # This array contains the information we want to display in the cells      # These are filled later      \"annotations\": [],      # No ticks on the x axis, show labels on top the of the chart      \"xaxis\": {\"ticks\": \"\", \"side\": \"top\"},      # No ticks on the y axis      # Add a space character for a small margin with the text      \"yaxis\": {\"ticks\": \"\", \"ticksuffix\": \" \"},  }    seasons = data[\"Seasons\"]  cities = data[\"Cities\"]  # Iterate over all cities  for city in range(len(cities)):      # Iterate over all seasons      for season in range(len(seasons)):          temperature = data[\"Temperatures\"][city][season]          # Create the annotation          annotation = {              # The name of the season              \"x\": seasons[season],              # The name of the city              \"y\": cities[city],              # The temperature, as a formatted string              \"text\": f\"{temperature}\\N{DEGREE SIGN}C\",              # Change the text color depending on the temperature              # so it results in a better contrast              \"font\": {\"color\": \"white\" if temperature < 14 else \"black\"},              # Remove the annotation arrow              \"showarrow\": False,          }          # Add the annotation to the layout's annotations array          layout[\"annotations\"].append(annotation)    page = \"\"\"  ## Heatmap - Annotated    <|{data}|chart|type=heatmap|z=Temperatures|x=Seasons|y=Cities|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui      # Function to plot: x^3/3 - x  def f(x):      return x * x * x / 3 - x      # x values: [-2.2, ..., 2.2]  x = [(x - 10) / 4.5 for x in range(0, 21)]    data = {      \"x\": x,      # y: [f(-2.2), ..., f(2.2)]      \"y\": [f(x) for x in x],  }      layout = {      # Chart title      \"title\": \"Local extrema\",      \"annotations\": [          # Annotation for local maximum (x = -1)          {\"text\": \"Local <b>max</b>\", \"font\": {\"size\": 20}, \"x\": -1, \"y\": f(-1)},          # Annotation for local minimum (x = 1)          {\"text\": \"Local <b>min</b>\", \"font\": {\"size\": 20}, \"x\": 1, \"y\": f(1), \"xanchor\": \"left\"},      ],  }    page = \"\"\"  # Advanced - Annotations    <|{data}|chart|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"Types\": [\"Website visit\", \"Downloads\", \"Prospects\", \"Invoice sent\", \"Closed\"],      \"Visits_us\": [13873, 10533, 5443, 2703, 908],      \"Visits_eu\": [7063, 4533, 3443, 1003, 1208],      \"Visits_ap\": [6873, 2533, 3443, 1703, 508],  }    # Columns for each trace  x = [\"Visits_us\", \"Visits_eu\", \"Visits_ap\"]    # Legend text for each trace  names = [\"US\", \"EU\", \"AP\"]    page = \"\"\"  # Funnel - Multiple traces    <|{data}|chart|type=funnel|x={x}|y=Types|name={names}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"Temperatures\": [          [17.2, 27.4, 28.6, 21.5],          [5.6, 15.1, 20.2, 8.1],          [26.6, 22.8, 21.8, 24.0],          [22.3, 15.5, 13.4, 19.6],      ],      \"Cities\": [\"Hanoi\", \"Paris\", \"Rio\", \"Sydney\"],      \"Seasons\": [\"Winter\", \"Spring\", \"Summer\", \"Autumn\"],  }    page = \"\"\"  # Heatmap - Basic    <|{data}|chart|type=heatmap|z=Temperatures|x=Seasons|y=Cities|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  # Face-to-face bar charts example  import numpy  from taipy.gui import Gui    n_years = 10    proportions_female = numpy.zeros(n_years)  proportions_male = numpy.zeros(n_years)    # Prepare the data set with random variations  proportions_female[0] = 0.4  proportions_male[0] = proportions_female[0] * (1 + numpy.random.normal(0, 0.1))    for i in range(1, n_years):      mean_i = (0.5 - proportions_female[i - 1]) / 5      new_value = proportions_female[i - 1] + numpy.random.normal(mean_i, 0.1)        new_value = min(max(0, new_value), 1)      proportions_female[i] = new_value      proportions_male[i] = proportions_female[i] * (1 + numpy.random.normal(0, 0.1))      data = {      \"Hobbies\": [          \"Archery\",          \"Tennis\",          \"Football\",          \"Basket\",          \"Volley\",          \"Golf\",          \"Video-Games\",          \"Reading\",          \"Singing\",          \"Music\",      ],      \"Female\": proportions_female,      # Negate these values so they appear to the left side      \"Male\": -proportions_male,  }    properties = {      # Shared y values      \"y\": \"Hobbies\",      # Bars for the female data set      \"x[1]\": \"Female\",      \"color[1]\": \"#c26391\",      # Bars for the male data set      \"x[2]\": \"Male\",      \"color[2]\": \"#5c91de\",      # Both data sets are represented with an horizontal orientation      \"orientation\": \"h\",      #      \"layout\": {          # This makes left and right bars aligned on the same y value          \"barmode\": \"overlay\",          # Set a relevant title for the x axis          \"xaxis\": {\"title\": \"Gender\"},          # Hide the legend          \"showlegend\": False,          \"margin\": {\"l\": 100},      },  }    page = \"\"\"  # Bar - Facing    <|{data}|chart|type=bar|properties={properties}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    from taipy.gui import Gui    # Random data set  data = [random.random() for i in range(100)]    # Normalize to show bin probabilities  options = {\"histnorm\": \"probability\"}    page = \"\"\"  # Histogram - Normalized    <|{data}|chart|type=histogram|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # You may need to install the scikit-learn package as well.  # -----------------------------------------------------------------------------------------  import numpy  import pandas  from sklearn.datasets import make_classification  from taipy.gui import Gui    # Let scikit-learn generate a random 2-class classification problem  features, label = make_classification(n_samples=1000, n_features=2, n_informative=2, n_redundant=0)    random_data = pandas.DataFrame({\"x\": features[:, 0], \"y\": features[:, 1], \"label\": label})    data_x = random_data[\"x\"]  class_A = [random_data.loc[i, \"y\"] if random_data.loc[i, \"label\"] == 0 else numpy.nan for i in range(len(random_data))]  class_B = [random_data.loc[i, \"y\"] if random_data.loc[i, \"label\"] == 1 else numpy.nan for i in range(len(random_data))]    data = {\"x\": random_data[\"x\"], \"Class A\": class_A, \"Class B\": class_B}    page = \"\"\"  # Scatter - Classification    <|{data}|chart|mode=markers|x=x|y[1]=Class A|y[2]=Class B|width=60%|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from itertools import accumulate    import numpy as np  from taipy.gui import Gui    grid_size = 10  data = [      {          # z is set to:          # - 0 if row+col is a multiple of 4          # - 1 if row+col is a multiple of 2          # - 0.5 otherwise          \"z\": [              [0.0 if (row + col) % 4 == 0 else 1 if (row + col) % 2 == 0 else 0.5 for col in range(grid_size)]              for row in range(grid_size)          ]      },      {          # A series of coordinates, growing exponentially          \"x\": [0] + list(accumulate(np.logspace(0, 1, grid_size))),          # A series of coordinates, shrinking exponentially          \"y\": [0] + list(accumulate(np.logspace(1, 0, grid_size))),      },  ]    # Axis template used in the layout object  axis_template = {      # Don't show any line or tick or label      \"showgrid\": False,      \"zeroline\": False,      \"ticks\": \"\",      \"showticklabels\": False,      \"visible\": False,  }    layout = {\"xaxis\": axis_template, \"yaxis\": axis_template}    options = {      # Remove the color scale display      \"showscale\": False  }    page = \"\"\"  ## Heatmap - Unequal block sizes    <|{data}|chart|type=heatmap|z=0/z|x=1/x|y=1/y|layout={layout}|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # 9-hole course  n_holes = 9    # Data set  # Each entry holds an array of values. One for each hole, plus one for th  data = {      # [\"Hole1\", \"Hole2\", ..., \"Hole9\"]      \"Hole\": [f\"Hole{h}\" for h in range(1, n_holes + 1)] + [\"Score\"],      # Par for each hole      \"Par\": [3, 4, 4, 5, 3, 5, 4, 5, 3] + [None],      # Score for each hole      \"Score\": [4, 4, 5, 4, 4, 5, 4, 5, 4] + [None],      # Represented as relative values except for the last one      \"M\": n_holes * [\"relative\"] + [\"total\"],  }    # Compute difference (Score-Par)  data[\"Diff\"] = [data[\"Score\"][i] - data[\"Par\"][i] for i in range(0, n_holes)] + [None]    # Show positive values in red, and negative values in green  options = {\"decreasing\": {\"marker\": {\"color\": \"green\"}}, \"increasing\": {\"marker\": {\"color\": \"red\"}}}    page = \"\"\"  # Waterfall - Styling    <|{data}|chart|type=waterfall|x=Hole|y=Diff|measure=M|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    from taipy.gui import Gui    # Common axis for all data: [1..10]  x = list(range(1, 11))  # Sample data  samples = [5, 7, 8, 4, 5, 9, 8, 8, 6, 5]    # Generate error data  # Error that adds to the input data  error_plus = [3 * random.random() + 0.5 for _ in x]  # Error substracted from to the input data  error_minus = [3 * random.random() + 0.5 for _ in x]    # Upper bound (y + error_plus)  error_upper = [y + e for (y, e) in zip(samples, error_plus)]  # Lower bound (y - error_minus)  error_lower = [y - e for (y, e) in zip(samples, error_minus)]    data = [      # Trace for samples      {\"x\": x, \"y\": samples},      # Trace for error range      {          # Roundtrip around the error bounds: onward then return          \"x\": x + list(reversed(x)),          # The two error bounds, with lower bound reversed          \"y\": error_upper + list(reversed(error_lower)),      },  ]    properties = {      # Error data      \"x[1]\": \"1/x\",      \"y[1]\": \"1/y\",      \"options[1]\": {          # Shows as filled area          \"fill\": \"toself\",          \"fillcolor\": \"rgba(70,70,240,0.6)\",          \"showlegend\": False,      },      # Don't show surrounding stroke      \"color[1]\": \"transparent\",      # Raw data (displayed on top of the error band)      \"x[2]\": \"0/x\",      \"y[2]\": \"0/y\",      \"color[2]\": \"rgb(140,50,50)\",      # Shown in the legend      \"name[2]\": \"Input\",  }    page = \"\"\"  # Continuous Error - Simple    <|{data}|chart|properties={properties}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"Products\": [          \"Nail polish\",          \"Eyebrow pencil\",          \"Rouge\",          \"Lipstick\",          \"Eyeshadows\",          \"Eyeliner\",          \"Foundation\",          \"Lip gloss\",          \"Mascara\",      ],      \"USA\": [12814, 13012, 11624, 8814, 12998, 12321, 10342, 22998, 11261],      \"China\": [3054, 5067, 7004, 9054, 12043, 15067, 10119, 12043, 10419],      \"EU\": [4376, 3987, 3574, 4376, 4572, 3417, 5231, 4572, 6134],      \"Africa\": [4229, 3932, 5221, 9256, 3308, 5432, 13701, 4008, 18712],  }    # Order the different traces  ys = [\"USA\", \"China\", \"EU\", \"Africa\"]    options = [      # For the USA      {\"stackgroup\": \"one\", \"groupnorm\": \"percent\"},      # For China      {\"stackgroup\": \"one\"},      # For the EU      {\"stackgroup\": \"one\"},      # For Africa      {\"stackgroup\": \"one\"},  ]    layout = {      # Show all values when hovering on a data point      \"hovermode\": \"x unified\"  }    page = \"\"\"  # Filled Area - Stacked Normalized    <|{data}|chart|mode=none|x=Products|y={ys}|options={options}|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import math    from taipy.gui import Gui    # One data point for each degree  theta = range(0, 360)      # Create a rose-like shaped radius-array  def create_rose(n_petals):      return [math.cos(math.radians(n_petals * angle)) for angle in theta]      data = {\"theta\": theta, \"r1\": create_rose(2), \"r2\": create_rose(3), \"r3\": create_rose(4)}    # We want three traces in the same chart  r = [\"r1\", \"r2\", \"r3\"]    layout = {      # Hide the legend      \"showlegend\": False,      \"polar\": {          # Hide the angular axis          \"angularaxis\": {\"visible\": False},          # Hide the radial axis          \"radialaxis\": {\"visible\": False},      },  }    page = \"\"\"  # Polar - Multiple    <|{data}|chart|type=scatterpolar|mode=lines|r={r}|theta=theta|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # You may need to install the yfinance package as well.  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"x\": [1, 2, 3, 4, 5],      \"y\": [10, 7, 4, 1, 5],      \"Sizes\": [20, 30, 40, 50, 30],      \"Symbols\": [\"circle-open\", \"triangle-up\", \"hexagram\", \"star-diamond\", \"circle-cross\"],  }    marker = {      \"color\": \"#77A\",      \"size\": \"Sizes\",      \"symbol\": \"Symbols\",  }    page = \"\"\"  # Bubble - Symbols    <|{data}|chart|mode=markers|x=x|y=y|marker={marker}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # You may need to install the yfinance package as well.  # -----------------------------------------------------------------------------------------  import yfinance  from taipy.gui import Gui    # Extraction of a few days of stock historical data for AAPL using  # the yfinance package (see https://pypi.org/project/yfinance/).  # The returned value is a Pandas DataFrame.  ticker = yfinance.Ticker(\"AAPL\")  stock = ticker.history(interval=\"1d\", start=\"2018-08-18\", end=\"2018-09-10\")  # Copy the DataFrame index to a new column  stock[\"Date\"] = stock.index    options = {      # Candlesticks that show decreasing values are orange      \"decreasing\": {\"line\": {\"color\": \"orange\"}},      # Candlesticks that show decreasing values are blue      \"increasing\": {\"line\": {\"color\": \"blue\"}},  }    layout = {      \"xaxis\": {          # Hide the range slider          \"rangeslider\": {\"visible\": False}      }  }    page = \"\"\"  # Candlestick - Styling    <|{stock}|chart|type=candlestick|x=Date|open=Open|close=Close|low=Low|high=High|options={options}|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"Types\": [\"Website visit\", \"Downloads\", \"Prospects\", \"Invoice sent\", \"Closed\"],      \"Visits\": [13873, 10533, 5443, 2703, 908],  }    marker = {      # Boxes are filled with a blue gradient color      \"color\": [\"hsl(210,50%,50%)\", \"hsl(210,60%,60%)\", \"hsl(210,70%,70%)\", \"hsl(210,80%,80%)\", \"hsl(210,90%,90%)\"],      # Lines get thicker, with an orange-to-green gradient color      \"line\": {\"width\": [1, 1, 2, 3, 4], \"color\": [\"f5720a\", \"f39c1d\", \"f0cc3d\", \"aadb12\", \"8cb709\"]},  }    options = {      # Lines connecting boxes are thick, dotted and green      \"connector\": {\"line\": {\"color\": \"green\", \"dash\": \"dot\", \"width\": 4}}  }    page = \"\"\"  # Funnel Chart - Custom markers    <|{data}|chart|type=funnel|x=Visits|y=Types|marker={marker}|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    from taipy.gui import Gui    # Random data set  data = [random.random() for i in range(500)]    options = {      # Enable the cumulative histogram      \"cumulative\": {\"enabled\": True}  }    page = \"\"\"  # Histogram - Cumulative    <|{data}|chart|type=histogram|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Create a star shape  data = {\"r\": [3, 1] * 5 + [3], \"theta\": list(range(0, 360, 36)) + [0]}    options = [      # First plot is filled with a yellow-ish color      {\"subplot\": \"polar\", \"fill\": \"toself\", \"fillcolor\": \"#E4FF87\"},      # Second plot is filled with a blue-ish color      {\"fill\": \"toself\", \"subplot\": \"polar2\", \"fillcolor\": \"#709BFF\"},  ]    layout = {      \"polar\": {          # This actually is the default value          \"angularaxis\": {              \"direction\": \"counterclockwise\",          },      },      \"polar2\": {          \"angularaxis\": {              # Rotate the axis 180\u00b0 (0 is on the left)              \"rotation\": 180,              # Orient the axis clockwise              \"direction\": \"clockwise\",              # Show the angles as radians              \"thetaunit\": \"radians\",          },      },      # Hide the legend      \"showlegend\": False,  }    page = \"\"\"  # Polar Charts - Direction    <|{data}|chart|type=scatterpolar|layout={layout}|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    value = \"XS\"    page = \"\"\"  # Slider - List of values    <|{value}|slider|lov=XXS;XS;S;M;L;XL;XXL|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import io  from decimal import Decimal, getcontext    from taipy.gui import Gui, download    # Initial precision  precision = 10      def pi(precision: int) -> list[int]:      \"\"\"Compute Pi to the required precision.        Adapted from https://docs.python.org/3/library/decimal.html      \"\"\"      saved_precision = getcontext().prec  # Save precision      getcontext().prec = precision      three = Decimal(3)  # substitute \"three=3.0\" for regular floats      lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 24      while s != lasts:          lasts = s          n, na = n + na, na + 8          d, da = d + da, da + 32          t = (t * n) / d          s += t      digits = []      while s != 0:          integral = int(s)          digits.append(integral)          s = (s - integral) * 10      getcontext().prec = saved_precision      return digits      # Generate the digits, save them in a CSV file content, and trigger a download action  # so the user can retrieve them  def download_pi(state):      digits = pi(state.precision)      buffer = io.StringIO()      buffer.write(\"index,digit\\n\")      for i, d in enumerate(digits):          buffer.write(f\"{i},{d}\\n\")      download(state, content=bytes(buffer.getvalue(), \"UTF-8\"), name=\"pi.csv\")      page = \"\"\"  # File Download - Dynamic content    Precision:    <|{precision}|slider|min=2|max=10000|>    <|{None}|file_download|on_action=download_pi|label=Download Pi digits|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    value = 9    page = \"\"\"  # Slider - Custom range    <|{value}|slider|min=1|max=10|>    Value: <|{value}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from datetime import date, timedelta    from taipy.gui import Gui    # Create the list of dates (all year 2000)  all_dates = {}  all_dates_str = []  start_date = date(2000, 1, 1)  end_date = date(2001, 1, 1)  a_date = start_date  while a_date < end_date:      date_str = a_date.strftime(\"%Y/%m/%d\")      all_dates_str.append(date_str)      all_dates[date_str] = a_date      a_date += timedelta(days=1)    # Initial selection: first and last day  dates = [all_dates_str[1], all_dates_str[-1]]  # These two variables are used in text controls  start_sel = all_dates[dates[0]]  end_sel = all_dates[dates[1]]      def on_change(state, _, var_value):      # Update the text controls      state.start_sel = all_dates[var_value[0]]      state.end_sel = all_dates[var_value[1]]      page = \"\"\"  # Slider - Date range    <|{dates}|slider|lov={all_dates_str}|>    Start: <|{start_sel}|text|format=d MMM|>    End: <|{end_sel}|text|format=d MMM|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import os  from decimal import Decimal, getcontext  from tempfile import NamedTemporaryFile    from taipy.gui import Gui, download    # Initial precision  precision = 10  # Stores the path to the temporary file  temp_path = None      def pi(precision: int) -> list[int]:      \"\"\"Compute Pi to the required precision.        Adapted from https://docs.python.org/3/library/decimal.html      \"\"\"      saved_precision = getcontext().prec  # Save precision      getcontext().prec = precision      three = Decimal(3)  # substitute \"three=3.0\" for regular floats      lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 24      while s != lasts:          lasts = s          n, na = n + na, na + 8          d, da = d + da, da + 32          t = (t * n) / d          s += t      digits = []      while s != 0:          integral = int(s)          digits.append(integral)          s = (s - integral) * 10      getcontext().prec = saved_precision      return digits      # Remove the temporary file  def clean_up(state):      os.remove(state.temp_path)      # Generate the digits, save them in a CSV temporary file, then trigger a download action  # for that file.  def download_pi(state):      digits = pi(state.precision)      with NamedTemporaryFile(\"r+t\", suffix=\".csv\", delete=False) as temp_file:          state.temp_path = temp_file.name          temp_file.write(\"index,digit\\n\")          for i, d in enumerate(digits):              temp_file.write(f\"{i},{d}\\n\")      download(state, content=temp_file.name, name=\"pi.csv\", on_action=clean_up)      page = \"\"\"  # File Download - Dynamic content    Precision:    <|{precision}|slider|min=2|max=10000|>    <|{None}|file_download|on_action=download_pi|label=Download Pi digits|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    value = 50    page = \"\"\"  # Slider - Simple    <|{value}|slider|>    Value: <|{value}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    value = 40    page = \"\"\"  # Slider - Vertical    <|{value}|slider|orientation=v|>    Value: <|{value}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Initial values  values = [20, 40, 80]    page = \"\"\"  # Slider - Range    <|{values}|slider|>    Selection: <|{values}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import os  import sys    from taipy._cli._base_cli import _CLI  from taipy.core._core_cli import _CoreCLI  from taipy.core._entity._migrate_cli import _MigrateCLI  from taipy.core._version._cli._version_cli import _VersionCLI  from taipy.gui._gui_cli import _GuiCLI    from ._cli._help_cli import _HelpCLI  from ._cli._run_cli import _RunCLI  from ._cli._scaffold_cli import _ScaffoldCLI  from .version import _get_version      def _entrypoint():      # Add the current working directory to path to execute version command on FS repo      sys.path.append(os.path.normpath(os.getcwd()))        _CLI._parser.add_argument(\"-v\", \"--version\", action=\"store_true\", help=\"Print the current Taipy version and exit.\")        _RunCLI.create_parser()      _GuiCLI.create_run_parser()      _CoreCLI.create_run_parser()        _VersionCLI.create_parser()      _ScaffoldCLI.create_parser()      _MigrateCLI.create_parser()      _HelpCLI.create_parser()        args = _CLI._parse()      if args.version:          print(f\"Taipy {_get_version()}\")          sys.exit(0)        _RunCLI.parse_arguments()      _HelpCLI.parse_arguments()      _VersionCLI.parse_arguments()      _MigrateCLI.parse_arguments()      _ScaffoldCLI.parse_arguments()        _CLI._remove_argument(\"help\")      _CLI._parser.print_help() "}
{"text": "import json  import os      def _get_version():      with open(f\"{os.path.dirname(os.path.abspath(__file__))}{os.sep}version.json\") as version_file:          version = json.load(version_file)          version_string = f'{version.get(\"major\", 0)}.{version.get(\"minor\", 0)}.{version.get(\"patch\", 0)}'          if vext := version.get(\"ext\"):              version_string = f\"{version_string}.{vext}\"      return version_string "}
{"text": "from importlib.util import find_spec    if find_spec(\"taipy\"):      if find_spec(\"taipy.config\"):          from taipy.config._init import *  # type: ignore        if find_spec(\"taipy.gui\"):          from taipy.gui._init import *  # type: ignore        if find_spec(\"taipy.core\"):          from taipy.core._init import *  # type: ignore        if find_spec(\"taipy.rest\"):          from taipy.rest._init import *  # type: ignore        if find_spec(\"taipy.gui_core\"):          from taipy.gui_core._init import *  # type: ignore        if find_spec(\"taipy.enterprise\"):          from taipy.enterprise._init import *  # type: ignore        if find_spec(\"taipy._run\"):          from taipy._run import _run as run  # type: ignore "}
{"text": "import sys  import typing as t    from flask import Flask    from taipy.core import Core  from taipy.gui import Gui  from taipy.rest import Rest    if sys.version_info >= (3, 10):      from typing import TypeGuard    _AppType = t.Union[Gui, Rest, Core]  _AppTypeT = t.TypeVar(\"_AppTypeT\", Gui, Rest, Core)      def _run(*services: _AppType, **kwargs) -> t.Optional[Flask]:      \"\"\"Run one or multiple Taipy services.        A Taipy service is an instance of a class that runs code as a Web application.        Parameters:          *services (Union[`Gui^`, `Rest^`, `Core^`]): Services to run, as separate arguments.<br/>              If several services are provided, all the services run simultaneously.<br/>              If this is empty or set to None, this method does nothing.          **kwargs: Other parameters to provide to the services.      \"\"\"        gui = __get_app(services, Gui)      rest = __get_app(services, Rest)      core = __get_app(services, Core)        if gui and core:          from taipy.core._core_cli import _CoreCLI          from taipy.gui._gui_cli import _GuiCLI            _CoreCLI.create_parser()          _GuiCLI.create_parser()        if rest or core:          if not core:              core = Core()          core.run()        if not rest and not gui:          return None        if gui and rest:          gui._set_flask(rest._app)  # type: ignore          return gui.run(**kwargs)      else:          app = rest or gui          assert app is not None  # Avoid pyright typing error          return app.run(**kwargs)      # Avoid black adding too many empty lines  # fmt: off  if sys.version_info >= (3, 10):      def __get_app(apps: t.Tuple[_AppType, ...], type_: t.Type[_AppTypeT]) -> t.Optional[_AppType]:          def filter_isinstance(tl: _AppType) -> TypeGuard[_AppTypeT]:              return isinstance(tl, type_)            return next(filter(filter_isinstance, apps), None)  else:      def __get_app(apps: t.Tuple[_AppType, ...], type_: t.Type[_AppTypeT]) -> t.Optional[_AppType]:          return next(filter(lambda a: isinstance(a, type_), apps), None)  # fmt: on "}
{"text": "from ._core import Core  from ._entity.submittable import Submittable  from .cycle.cycle import Cycle  from .cycle.cycle_id import CycleId  from .data.data_node import DataNode  from .data.data_node_id import DataNodeId  from .job.job import Job  from .job.job_id import JobId  from .job.status import Status  from .scenario.scenario import Scenario  from .scenario.scenario_id import ScenarioId  from .sequence.sequence import Sequence  from .sequence.sequence_id import SequenceId  from .taipy import (      cancel_job,      clean_all_entities_by_version,      compare_scenarios,      create_global_data_node,      create_scenario,      delete,      delete_job,      delete_jobs,      exists,      export_scenario,      get,      get_cycles,      get_cycles_scenarios,      get_data_nodes,      get_entities_by_config_id,      get_jobs,      get_latest_job,      get_parents,      get_primary,      get_primary_scenarios,      get_scenarios,      get_sequences,      get_tasks,      is_deletable,      is_editable,      is_promotable,      is_readable,      is_submittable,      set,      set_primary,      submit,      subscribe_scenario,      subscribe_sequence,      tag,      unsubscribe_scenario,      unsubscribe_sequence,      untag,  )  from .task.task import Task  from .task.task_id import TaskId "}
{"text": "\"\"\"# Taipy Core    The Taipy Core package is a Python library designed to build powerful, customized, data-driven back-end  applications. It provides the tools to help Python developers transform their algorithms into a  complete back-end application.  More details on the [Taipy Core](../../core/index.md) functionalities are available in the user manual.    To build a Taipy Core application, the first step consists of setting up the Taipy configuration to design  your application's characteristics and behaviors.  Import `Config^` from the `taipy.config^` module, then use the various methods of the `Config^` singleton class to  configure your core application. In particular, configure the  [data nodes](../../core/config/data-node-config.md), [tasks](../../core/config/task-config.md),  and [scenarios](../../core/config/scenario-config.md).  Please refer to the [Core configuration user manual](../../core/config/index.md) for more information and  detailed examples.    Once your application is configured, import module `import taipy as tp` so you can use any function described  in the following section on [Functionc](#functions). In particular, the most used functions are `tp.create_scenario()`,  `tp.get_scenarios()`, `tp.get_data_nodes()`, `tp.submit()`, used to get, create, and submit entities.    !!! Note        Taipy Core provides a runnable service, `Core^` that runs as a service in a dedicated thread. The purpose is to      have a dedicated thread responsible for dispatching the submitted jobs to an available executor for their execution.        In particular, this `Core^` service is automatically run when Core is used with Taipy REST or Taipy GUI. See the      [running services](../../run-deploy/run/running_services.md) page of the user manual for more details.  \"\"\"    from ._init import *  from ._init_version import _read_version  from .common.mongo_default_document import MongoDefaultDocument  from .data.data_node_id import Edit  from .exceptions import exceptions    __version__ = _read_version() "}
{"text": "import json  import os  from pathlib import Path      def _read_version():      with open(f\"{Path(os.path.abspath(__file__)).parent}{os.sep}version.json\") as version_file:          version = json.load(version_file)          version_string = f'{version.get(\"major\", 0)}.{version.get(\"minor\", 0)}.{version.get(\"patch\", 0)}'          if vext := version.get(\"ext\"):              version_string = f\"{version_string}.{vext}\"      return version_string "}
{"text": "from multiprocessing import Lock  from typing import Optional    from taipy.config import Config  from taipy.logger._taipy_logger import _TaipyLogger    from ._backup._backup import _init_backup_file_with_storage_folder  from ._core_cli import _CoreCLI  from ._orchestrator._dispatcher._job_dispatcher import _JobDispatcher  from ._orchestrator._orchestrator import _Orchestrator  from ._orchestrator._orchestrator_factory import _OrchestratorFactory  from ._version._version_manager_factory import _VersionManagerFactory  from .config import CoreSection  from .exceptions.exceptions import CoreServiceIsAlreadyRunning      class Core:      \"\"\"      Core service      \"\"\"        _is_running = False      __lock_is_running = Lock()        __logger = _TaipyLogger._get_logger()        _orchestrator: Optional[_Orchestrator] = None      _dispatcher: Optional[_JobDispatcher] = None        def __init__(self):          \"\"\"          Initialize a Core service.          \"\"\"          pass        def run(self, force_restart=False):          \"\"\"          Start a Core service.            This function checks the configuration, manages application's version,          and starts a dispatcher and lock the Config.          \"\"\"          if self.__class__._is_running:              raise CoreServiceIsAlreadyRunning            with self.__class__.__lock_is_running:              self.__class__._is_running = True            self.__update_core_section()          self.__manage_version()          self.__check_and_block_config()            if self._orchestrator is None:              self._orchestrator = _OrchestratorFactory._build_orchestrator()            self.__start_dispatcher(force_restart)        def stop(self):          \"\"\"          Stop the Core service.            This function stops the dispatcher and unblock the Config for update.          \"\"\"          Config.unblock_update()            if self._dispatcher:              self._dispatcher = _OrchestratorFactory._remove_dispatcher()              self.__logger.info(\"Core service has been stopped.\")            with self.__class__.__lock_is_running:              self.__class__._is_running = False        @staticmethod      def __update_core_section():          _CoreCLI.create_parser()          Config._applied_config._unique_sections[CoreSection.name]._update(_CoreCLI.parse_arguments())        @staticmethod      def __manage_version():          _VersionManagerFactory._build_manager()._manage_version()          Config._applied_config._unique_sections[CoreSection.name]._update(              {\"version_number\": _VersionManagerFactory._build_manager()._get_latest_version()}          )        @staticmethod      def __check_and_block_config():          Config.check()          Config.block_update()          _init_backup_file_with_storage_folder()        def __start_dispatcher(self, force_restart):          if dispatcher := _OrchestratorFactory._build_dispatcher(force_restart=force_restart):              self._dispatcher = dispatcher            if Config.job_config.is_development:              _Orchestrator._check_and_execute_jobs_if_development_mode() "}
{"text": "#!/usr/bin/env python    \"\"\"The setup script.\"\"\"  import json  import os    from setuptools import find_namespace_packages, find_packages, setup    with open(\"README.md\") as readme_file:      readme = readme_file.read()    with open(f\"src{os.sep}taipy{os.sep}core{os.sep}version.json\") as version_file:      version = json.load(version_file)      version_string = f'{version.get(\"major\", 0)}.{version.get(\"minor\", 0)}.{version.get(\"patch\", 0)}'      if vext := version.get(\"ext\"):          version_string = f\"{version_string}.{vext}\"    requirements = [      \"pyarrow>=10.0.1,<11.0\",      \"networkx>=2.6,<3.0\",      \"openpyxl>=3.1.2,<3.2\",      \"modin[dask]>=0.23.0,<1.0\",      \"pymongo[srv]>=4.2.0,<5.0\",      \"sqlalchemy>=2.0.16,<2.1\",      \"toml>=0.10,<0.11\",      \"taipy-config@git+https://git@github.com/Avaiga/taipy-config.git@develop\",  ]    test_requirements = [\"pytest>=3.8\"]    extras_require = {      \"fastparquet\": [\"fastparquet==2022.11.0\"],      \"mssql\": [\"pyodbc>=4,<4.1\"],      \"mysql\": [\"pymysql>1,<1.1\"],      \"postgresql\": [\"psycopg2>2.9,<2.10\"],  }    setup(      author=\"Avaiga\",      author_email=\"dev@taipy.io\",      python_requires=\">=3.8\",      classifiers=[          \"Intended Audience :: Developers\",          \"License :: OSI Approved :: Apache Software License\",          \"Natural Language :: English\",          \"Programming Language :: Python :: 3\",          \"Programming Language :: Python :: 3.8\",          \"Programming Language :: Python :: 3.9\",          \"Programming Language :: Python :: 3.10\",          \"Programming Language :: Python :: 3.11\",      ],      description=\"A Python library to build powerful and customized data-driven back-end applications.\",      install_requires=requirements,      long_description=readme,      long_description_content_type=\"text/markdown\",      license=\"Apache License 2.0\",      keywords=\"taipy-core\",      name=\"taipy-core\",      package_dir={\"\": \"src\"},      packages=find_namespace_packages(where=\"src\") + find_packages(include=[\"taipy\", \"taipy.core\", \"taipy.core.*\"]),      include_package_data=True,      test_suite=\"tests\",      tests_require=test_requirements,      url=\"https://github.com/avaiga/taipy-core\",      version=version_string,      zip_safe=False,      extras_require=extras_require,  ) "}
{"text": "from typing import Dict    from taipy._cli._base_cli import _CLI    from .config import CoreSection      class _CoreCLI:      \"\"\"Command-line interface for Taipy Core application.\"\"\"        __MODE_ARGS: Dict[str, Dict] = {          \"--development\": {              \"action\": \"store_true\",              \"dest\": \"taipy_development\",              \"help\": \"\"\"                  When execute Taipy application in `development` mode, all entities from the previous development version                  will be deleted before running new Taipy application.              \"\"\",          },          \"--experiment\": {              \"dest\": \"taipy_experiment\",              \"nargs\": \"?\",              \"const\": \"\",              \"metavar\": \"VERSION\",              \"help\": \"\"\"                  When execute Taipy application in `experiment` mode, the current Taipy application is saved to a new                  version. If version name already exists, check for compatibility with current Python Config and run the                  application. Without being specified, the version number will be a random string.              \"\"\",          },          \"--production\": {              \"dest\": \"taipy_production\",              \"nargs\": \"?\",              \"const\": \"\",              \"metavar\": \"VERSION\",              \"help\": \"\"\"                  When execute in `production` mode, the current version is used in production. All production versions                  should have the same configuration and share all entities. Without being specified, the latest version                  is used.              \"\"\",          },      }        __FORCE_ARGS: Dict[str, Dict] = {          \"--force\": {              \"dest\": \"taipy_force\",              \"action\": \"store_true\",              \"help\": \"\"\"                  Force override the configuration of the version if existed and run the application. Default to False.              \"\"\",          },          \"--no-force\": {              \"dest\": \"no_taipy_force\",              \"action\": \"store_true\",              \"help\": \"Stop the application if any Config conflict exists.\",          },      }        @classmethod      def create_parser(cls):          core_parser = _CLI._add_groupparser(\"Taipy Core\", \"Optional arguments for Taipy Core service\")            mode_group = core_parser.add_mutually_exclusive_group()          for mode_arg, mode_arg_dict in cls.__MODE_ARGS.items():              mode_group.add_argument(mode_arg, cls.__add_taipy_prefix(mode_arg), **mode_arg_dict)            force_group = core_parser.add_mutually_exclusive_group()          for force_arg, force_arg_dict in cls.__FORCE_ARGS.items():              force_group.add_argument(cls.__add_taipy_prefix(force_arg), **force_arg_dict)        @classmethod      def create_run_parser(cls):          run_parser = _CLI._add_subparser(\"run\", help=\"Run a Taipy application.\")          mode_group = run_parser.add_mutually_exclusive_group()          for mode_arg, mode_arg_dict in cls.__MODE_ARGS.items():              mode_group.add_argument(mode_arg, **mode_arg_dict)            force_group = run_parser.add_mutually_exclusive_group()          for force_arg, force_arg_dict in cls.__FORCE_ARGS.items():              force_group.add_argument(force_arg, **force_arg_dict)        @classmethod      def parse_arguments(cls):          args = _CLI._parse()          as_dict = {}          if args.taipy_development:              as_dict[CoreSection._MODE_KEY] = CoreSection._DEVELOPMENT_MODE          elif args.taipy_experiment is not None:              as_dict[CoreSection._MODE_KEY] = CoreSection._EXPERIMENT_MODE              as_dict[CoreSection._VERSION_NUMBER_KEY] = args.taipy_experiment          elif args.taipy_production is not None:              as_dict[CoreSection._MODE_KEY] = CoreSection._PRODUCTION_MODE              as_dict[CoreSection._VERSION_NUMBER_KEY] = args.taipy_production            if args.taipy_force:              as_dict[CoreSection._FORCE_KEY] = True          elif args.no_taipy_force:              as_dict[CoreSection._FORCE_KEY] = False            return as_dict        @classmethod      def __add_taipy_prefix(cls, key: str):          if key.startswith(\"--no-\"):              return key[:5] + \"taipy-\" + key[5:]            return key[:2] + \"taipy-\" + key[2:] "}
{"text": "import json  import re  from datetime import datetime, timedelta      class _Decoder(json.JSONDecoder):      def __init__(self, *args, **kwargs):          json.JSONDecoder.__init__(self, object_hook=self.object_hook, *args, **kwargs)        def _str_to_timedelta(self, timedelta_str: str) -> timedelta:          \"\"\"          Parse a time string e.g. (2h13m) into a timedelta object.            :param timedelta_str: A string identifying a duration.  (eg. 2h13m)          :return datetime.timedelta: A datetime.timedelta object          \"\"\"          regex = re.compile(              r\"^((?P<days>[\\.\\d]+?)d)? *\"              r\"((?P<hours>[\\.\\d]+?)h)? *\"              r\"((?P<minutes>[\\.\\d]+?)m)? *\"              r\"((?P<seconds>[\\.\\d]+?)s)?$\"          )          parts = regex.match(timedelta_str)          if not parts:              raise TypeError(\"Can not deserialize string into timedelta\")          time_params = {name: float(param) for name, param in parts.groupdict().items() if param}          # mypy has an issue with dynamic keyword parameters, hence the type ignore on the line bellow.          return timedelta(**time_params)  # type: ignore        def object_hook(self, source):          if source.get(\"__type__\") == \"Datetime\":              return datetime.fromisoformat(source.get(\"__value__\"))          if source.get(\"__type__\") == \"Timedelta\":              return self._str_to_timedelta(source.get(\"__value__\"))          else:              return source      def loads(d):      return json.loads(d, cls=_Decoder) "}
{"text": "import pathlib  from abc import abstractmethod  from typing import Any, Dict, Generic, Iterable, List, Optional, TypeVar, Union    ModelType = TypeVar(\"ModelType\")  Entity = TypeVar(\"Entity\")      class _AbstractRepository(Generic[ModelType, Entity]):      @abstractmethod      def _save(self, entity: Entity):          \"\"\"          Save an entity in the repository.            Parameters:              entity: The data from an object.          \"\"\"          raise NotImplementedError        @abstractmethod      def _exists(self, entity_id: str) -> bool:          \"\"\"          Check if an entity with id entity_id exists in the repository.          Parameters:              entity_id: The entity id, i.e., its primary key.            Returns:              True if the entity id exists.          \"\"\"          raise NotImplementedError        @abstractmethod      def _load(self, entity_id: str) -> Entity:          \"\"\"          Retrieve the entity data from the repository.          Parameters:              entity_id: The entity id, i.e., its primary key.            Returns:              An entity.          \"\"\"          raise NotImplementedError        @abstractmethod      def _load_all(self, filters: Optional[List[Dict]] = None) -> List[Entity]:          \"\"\"          Retrieve all the entities' data from the repository taking any passed filter into account.            Returns:              A list of entities.          \"\"\"          raise NotImplementedError        @abstractmethod      def _delete(self, entity_id: str):          \"\"\"          Delete an entity in the repository.            Parameters:              entity_id: The id of the entity to be deleted.          \"\"\"          raise NotImplementedError        @abstractmethod      def _delete_all(self):          \"\"\"          Delete all entities from the repository.          \"\"\"          raise NotImplementedError        @abstractmethod      def _delete_many(self, ids: Iterable[str]):          \"\"\"          Delete all entities from the list of ids from the repository.            Parameters:              ids: List of ids to be deleted.          \"\"\"          raise NotImplementedError        @abstractmethod      def _delete_by(self, attribute: str, value: str):          \"\"\"          Delete all entities from the list of ids from the repository.            Parameters:              attribute: The entity property that is the key to the search.              value: The value of the attribute that are being searched.          \"\"\"          raise NotImplementedError        @abstractmethod      def _search(self, attribute: str, value: Any, filters: Optional[List[Dict]] = None) -> List[Entity]:          \"\"\"          Parameters:              attribute: The entity property that is the key to the search.              value: The value of the attribute that are being searched.            Returns:              A list of entities that match the search criteria.          \"\"\"          raise NotImplementedError        @abstractmethod      def _export(self, entity_id: str, folder_path: Union[str, pathlib.Path]):          \"\"\"          Export an entity from the repository.            Parameters:              entity_id (str): The id of the entity to be exported.              folder_path (Union[str, pathlib.Path]): The folder path to export the entity to.          \"\"\"          raise NotImplementedError "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import json  from datetime import datetime, timedelta  from enum import Enum  from typing import Any      class _Encoder(json.JSONEncoder):      def _timedelta_to_str(self, obj: timedelta) -> str:          total_seconds = obj.total_seconds()          return (              f\"{int(total_seconds // 86400)}d\"              f\"{int(total_seconds % 86400 // 3600)}h\"              f\"{int(total_seconds % 3600 // 60)}m\"              f\"{int(total_seconds % 60)}s\"          )        def default(self, o: Any):          if isinstance(o, Enum):              result = o.value          elif isinstance(o, datetime):              result = {\"__type__\": \"Datetime\", \"__value__\": o.isoformat()}          elif isinstance(o, timedelta):              result = {\"__type__\": \"Timedelta\", \"__value__\": self._timedelta_to_str(o)}          else:              result = json.JSONEncoder.default(self, o)          return result      def dumps(d):      return json.dumps(d, cls=_Encoder) "}
{"text": "from abc import ABC, abstractmethod      class _AbstractConverter(ABC):      @classmethod      @abstractmethod      def _entity_to_model(cls, entity):          raise NotImplementedError        @classmethod      @abstractmethod      def _model_to_entity(cls, model):          raise NotImplementedError "}
{"text": "import dataclasses  import enum  import json  from typing import Any, Dict    from sqlalchemy import Table    from ._decoder import _Decoder  from ._encoder import _Encoder      class _BaseModel:      __table__: Table        def __iter__(self):          for attr, value in self.__dict__.items():              yield attr, value        def to_dict(self) -> Dict[str, Any]:          model_dict = {**dataclasses.asdict(self)}            for k, v in model_dict.items():              if isinstance(v, enum.Enum):                  model_dict[k] = repr(v)          return model_dict        @staticmethod      def _serialize_attribute(value):          return json.dumps(value, ensure_ascii=False, cls=_Encoder)        @staticmethod      def _deserialize_attribute(value):          if isinstance(value, str):              return json.loads(value.replace(\"'\", '\"'), cls=_Decoder)          return value        @staticmethod      def from_dict(data: Dict[str, Any]):          pass        def to_list(self):          pass "}
{"text": "import sqlite3  from functools import lru_cache  from sqlite3 import Connection    from sqlalchemy.dialects import sqlite  from sqlalchemy.schema import CreateTable    from taipy.config.config import Config    from ...exceptions import MissingRequiredProperty      def dict_factory(cursor, row):      d = {}      for idx, col in enumerate(cursor.description):          d[col[0]] = row[idx]      return d      class _SQLConnection:      _connection = None        @classmethod      def init_db(cls):          if cls._connection:              return cls._connection            cls._connection = _build_connection()          cls._connection.row_factory = dict_factory            from ..._version._version_model import _VersionModel          from ...cycle._cycle_model import _CycleModel          from ...data._data_model import _DataNodeModel          from ...job._job_model import _JobModel          from ...scenario._scenario_model import _ScenarioModel          from ...submission._submission_model import _SubmissionModel          from ...task._task_model import _TaskModel            cls._connection.execute(              str(CreateTable(_CycleModel.__table__, if_not_exists=True).compile(dialect=sqlite.dialect()))          )          cls._connection.execute(              str(CreateTable(_DataNodeModel.__table__, if_not_exists=True).compile(dialect=sqlite.dialect()))          )          cls._connection.execute(              str(CreateTable(_JobModel.__table__, if_not_exists=True).compile(dialect=sqlite.dialect()))          )          cls._connection.execute(              str(CreateTable(_ScenarioModel.__table__, if_not_exists=True).compile(dialect=sqlite.dialect()))          )          cls._connection.execute(              str(CreateTable(_TaskModel.__table__, if_not_exists=True).compile(dialect=sqlite.dialect()))          )          cls._connection.execute(              str(CreateTable(_VersionModel.__table__, if_not_exists=True).compile(dialect=sqlite.dialect()))          )          cls._connection.execute(              str(CreateTable(_SubmissionModel.__table__, if_not_exists=True).compile(dialect=sqlite.dialect()))          )            return cls._connection      def _build_connection() -> Connection:      # Set SQLite threading mode to Serialized, means that threads may share the module, connections and cursors      sqlite3.threadsafety = 3        properties = Config.core.repository_properties      try:          db_location = properties[\"db_location\"]      except KeyError:          raise MissingRequiredProperty(\"Missing property db_location.\")        return __build_connection(db_location)      @lru_cache  def __build_connection(db_location: str):      return sqlite3.connect(db_location, check_same_thread=False) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from sqlalchemy.orm import declarative_base, registry    _SQLBaseModel = declarative_base()  mapper_registry = registry() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "  import os    from taipy.config import Config    __BACKUP_FILE_PATH_ENVIRONMENT_VARIABLE_NAME = \"TAIPY_BACKUP_FILE_PATH\"      def _init_backup_file_with_storage_folder():      if preserve_file_path := os.getenv(__BACKUP_FILE_PATH_ENVIRONMENT_VARIABLE_NAME):          with open(preserve_file_path, \"a\") as f:              f.write(f\"{Config.core.storage_folder}\\n\")      def _append_to_backup_file(new_file_path: str):      if preserve_file_path := os.getenv(__BACKUP_FILE_PATH_ENVIRONMENT_VARIABLE_NAME):          storage_folder = os.path.abspath(Config.core.storage_folder) + os.sep          if not os.path.abspath(new_file_path).startswith(storage_folder):              with open(preserve_file_path, \"a\") as f:                  f.write(f\"{new_file_path}\\n\")      def _remove_from_backup_file(to_remove_file_path: str):      if preserve_file_path := os.getenv(__BACKUP_FILE_PATH_ENVIRONMENT_VARIABLE_NAME, None):          storage_folder = os.path.abspath(Config.core.storage_folder) + os.sep          if not os.path.abspath(to_remove_file_path).startswith(storage_folder):              try:                  with open(preserve_file_path, \"r+\") as f:                      old_backup = f.read()                      to_remove_file_path = to_remove_file_path + \"\\n\"                        # To avoid removing the file path of different data nodes that are pointing                      # to the same file. We will only replace the file path only once.                      if old_backup.startswith(to_remove_file_path):                          new_backup = old_backup.replace(to_remove_file_path, \"\", 1)                      else:                          new_backup = old_backup.replace(\"\\n\" + to_remove_file_path, \"\\n\", 1)                        if new_backup is not old_backup:                          f.seek(0)                          f.write(new_backup)                          f.truncate()              except Exception:                  pass      def _replace_in_backup_file(old_file_path: str, new_file_path: str):      _remove_from_backup_file(old_file_path)      _append_to_backup_file(new_file_path) "}
{"text": "from taipy.config import _inject_section  from taipy.config.checker._checker import _Checker  from taipy.config.common.frequency import Frequency  # type: ignore  from taipy.config.common.scope import Scope  # type: ignore  from taipy.config.config import Config  # type: ignore  from taipy.config.global_app.global_app_config import GlobalAppConfig  # type: ignore    from .checkers._config_id_checker import _ConfigIdChecker  from .checkers._core_section_checker import _CoreSectionChecker  from .checkers._data_node_config_checker import _DataNodeConfigChecker  from .checkers._job_config_checker import _JobConfigChecker  from .checkers._scenario_config_checker import _ScenarioConfigChecker  from .checkers._task_config_checker import _TaskConfigChecker  from .core_section import CoreSection  from .data_node_config import DataNodeConfig  from .job_config import JobConfig  from .migration_config import MigrationConfig  from .scenario_config import ScenarioConfig  from .task_config import TaskConfig    _inject_section(      JobConfig,      \"job_config\",      JobConfig.default_config(),      [(\"configure_job_executions\", JobConfig._configure)],      add_to_unconflicted_sections=True,  )  _inject_section(      DataNodeConfig,      \"data_nodes\",      DataNodeConfig.default_config(),      [          (\"configure_data_node\", DataNodeConfig._configure),          (\"configure_data_node_from\", DataNodeConfig._configure_from),          (\"set_default_data_node_configuration\", DataNodeConfig._set_default_configuration),          (\"configure_csv_data_node\", DataNodeConfig._configure_csv),          (\"configure_json_data_node\", DataNodeConfig._configure_json),          (\"configure_parquet_data_node\", DataNodeConfig._configure_parquet),          (\"configure_sql_table_data_node\", DataNodeConfig._configure_sql_table),          (\"configure_sql_data_node\", DataNodeConfig._configure_sql),          (\"configure_mongo_collection_data_node\", DataNodeConfig._configure_mongo_collection),          (\"configure_in_memory_data_node\", DataNodeConfig._configure_in_memory),          (\"configure_pickle_data_node\", DataNodeConfig._configure_pickle),          (\"configure_excel_data_node\", DataNodeConfig._configure_excel),          (\"configure_generic_data_node\", DataNodeConfig._configure_generic),      ],  )  _inject_section(      TaskConfig,      \"tasks\",      TaskConfig.default_config(),      [          (\"configure_task\", TaskConfig._configure),          (\"set_default_task_configuration\", TaskConfig._set_default_configuration),      ],  )  _inject_section(      ScenarioConfig,      \"scenarios\",      ScenarioConfig.default_config(),      [          (\"configure_scenario\", ScenarioConfig._configure),          (\"set_default_scenario_configuration\", ScenarioConfig._set_default_configuration),      ],  )  _inject_section(      MigrationConfig,      \"migration_functions\",      MigrationConfig.default_config(),      [(\"add_migration_function\", MigrationConfig._add_migration_function)],      add_to_unconflicted_sections=True,  )  _inject_section(      CoreSection,      \"core\",      CoreSection.default_config(),      [(\"configure_core\", CoreSection._configure)],      add_to_unconflicted_sections=True,  )    _Checker.add_checker(_ConfigIdChecker)  _Checker.add_checker(_CoreSectionChecker)  _Checker.add_checker(_DataNodeConfigChecker)  _Checker.add_checker(_JobConfigChecker)  # We don't need to add _MigrationConfigChecker because it is run only when the Core service is run.  _Checker.add_checker(_TaskConfigChecker)  _Checker.add_checker(_ScenarioConfigChecker) "}
{"text": "import collections.abc  from copy import deepcopy  from typing import Any, Callable, Dict, Optional, Union    from taipy.config._config import _Config  from taipy.config.common._template_handler import _TemplateHandler as _tpl  from taipy.config.config import Config  from taipy.config.section import Section  from taipy.config.unique_section import UniqueSection      class MigrationConfig(UniqueSection):      \"\"\"      Configuration fields needed to register migration functions from an old version to newer one.        Attributes:          migration_fcts (Dict[str, Dict[str, Callable]]): A dictionary that maps the version that entities are              migrated from to the migration functions.          **properties (dict[str, Any]): A dictionary of additional properties.      \"\"\"        name = \"VERSION_MIGRATION\"        _MIGRATION_FCTS_KEY = \"migration_fcts\"        def __init__(          self,          migration_fcts: Dict[str, Dict[str, Callable]],          **properties,      ):          self.migration_fcts = migration_fcts            super().__init__(**properties)        def __copy__(self):          return MigrationConfig(              deepcopy(self.migration_fcts),              **deepcopy(self._properties),          )        def _clean(self):          self.migration_fcts.clear()          self._properties.clear()        def __getattr__(self, item: str) -> Optional[Any]:          return _tpl._replace_templates(self._properties.get(item))  # type: ignore        @classmethod      def default_config(cls):          return MigrationConfig({})        def _to_dict(self):          return {              self._MIGRATION_FCTS_KEY: self.migration_fcts,              **self._properties,          }        @classmethod      def _from_dict(cls, as_dict: Dict[str, Any], id: str, config: Optional[_Config]):          return MigrationConfig(**as_dict)        def _update(self, as_dict, default_section=None):          def deep_update(d, u):              for k, v in u.items():                  if isinstance(v, collections.abc.Mapping):                      d[k] = deep_update(d.get(k, {}), v)                  else:                      d[k] = v              return d            migration_fcts = as_dict.pop(self._MIGRATION_FCTS_KEY)          deep_update(self.migration_fcts, migration_fcts)            self._properties.update(as_dict)        @staticmethod      def _add_migration_function(          target_version: str,          config: Union[Section, str],          migration_fct: Callable,          **properties,      ):          \"\"\"Add a migration function for a Configuration to migrate entities to the target version.            Parameters:              target_version (str): The production version that entities are migrated to.              config (Union[Section, str]): The configuration or the `id` of the config that needs to migrate.              migration_fct (Callable): Migration function that takes an entity as input and returns a new entity                  that is compatible with the target production version.              **properties (Dict[str, Any]): A keyworded variable length list of additional arguments.          Returns:              `MigrationConfig^`: The Migration configuration.          \"\"\"          config_id = config if isinstance(config, str) else config.id          migration_fcts = {target_version: {config_id: migration_fct}}            section = MigrationConfig(              migration_fcts,              **properties,          )          Config._register(section)          return Config.unique_sections[MigrationConfig.name] "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from copy import copy  from typing import Any, Dict, Optional, Union    from taipy.config import Config  from taipy.config._config import _Config  from taipy.config.common._template_handler import _TemplateHandler as _tpl  from taipy.config.unique_section import UniqueSection    from ..exceptions.exceptions import ModeNotAvailable      class JobConfig(UniqueSection):      \"\"\"      Configuration fields related to the jobs' executions.        Parameters:          mode (str): The Taipy operating mode. By default, the \"development\" mode is set for testing and debugging the              executions of jobs. A \"standalone\" mode is also available.          **properties (dict[str, any]): A dictionary of additional properties.      \"\"\"        name = \"JOB\"        _MODE_KEY = \"mode\"      _STANDALONE_MODE = \"standalone\"      _DEVELOPMENT_MODE = \"development\"      _DEFAULT_MODE = _DEVELOPMENT_MODE      _MODES = [_STANDALONE_MODE, _DEVELOPMENT_MODE]        def __init__(self, mode: Optional[str] = None, **properties):          self.mode = mode or self._DEFAULT_MODE          self._config = self._create_config(self.mode, **properties)          super().__init__(**properties)        def __copy__(self):          return JobConfig(self.mode, **copy(self._properties))        def __getattr__(self, key: str) -> Optional[Any]:          return self._config.get(key, None)        @classmethod      def default_config(cls):          return JobConfig(cls._DEFAULT_MODE)        def _clean(self):          self.mode = self._DEFAULT_MODE          self._config = self._create_config(self.mode)        def _to_dict(self):          as_dict = {}          if self.mode is not None:              as_dict[self._MODE_KEY] = self.mode          as_dict.update(self._config)          return as_dict        @classmethod      def _from_dict(cls, config_as_dict: Dict[str, Any], id=None, config: Optional[_Config] = None):          mode = config_as_dict.pop(cls._MODE_KEY, None)          job_config = JobConfig(mode, **config_as_dict)          return job_config        def _update(self, as_dict: Dict[str, Any], default_section=None):          mode = _tpl._replace_templates(as_dict.pop(self._MODE_KEY, self.mode))          if self.mode != mode:              self.mode = mode              self._config = self._create_config(self.mode, **as_dict)          if self._config is not None:              self._update_config(as_dict)        @staticmethod      def _configure(          mode: Optional[str] = None, max_nb_of_workers: Optional[Union[int, str]] = None, **properties      ) -> \"JobConfig\":          \"\"\"Configure job execution.            Parameters:              mode (Optional[str]): The job execution mode.                  Possible values are: *\"standalone\"* (the default value) or *\"development\"*.              max_nb_of_workers (Optional[int, str]): Parameter used only in default *\"standalone\"* mode.                  This indicates the maximum number of jobs able to run in parallel.<br/>                  The default value is 1.<br/>                  A string can be provided to dynamically set the value using an environment                  variable. The string must follow the pattern: `ENV[&lt;env_var&gt;]` where                  `&lt;env_var&gt;` is the name of an environment variable.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new job execution configuration.          \"\"\"          section = JobConfig(mode, max_nb_of_workers=max_nb_of_workers, **properties)          Config._register(section)          return Config.unique_sections[JobConfig.name]        def _update_config(self, config_as_dict: Dict[str, Any]):          for k, v in config_as_dict.items():              type_to_convert = type(self.get_default_config(self.mode).get(k, None)) or str              value = _tpl._replace_templates(v, type_to_convert)              if value is not None:                  self._config[k] = value        @property      def is_standalone(self) -> bool:          \"\"\"True if the config is set to standalone mode\"\"\"          return self.mode == self._STANDALONE_MODE        @property      def is_development(self) -> bool:          \"\"\"True if the config is set to development mode\"\"\"          return self.mode == self._DEVELOPMENT_MODE        @classmethod      def get_default_config(cls, mode: str) -> Dict[str, Any]:          if cls.is_standalone:  # type: ignore              return {\"max_nb_of_workers\": 1}          if cls.is_development:              return {}          raise ModeNotAvailable(mode)        @classmethod      def _create_config(cls, mode, **properties):          return {**cls.get_default_config(mode), **properties} "}
{"text": "from typing import Set    from taipy.config._config import _Config  from taipy.config.checker._checkers._config_checker import _ConfigChecker  from taipy.config.checker.issue_collector import IssueCollector    from ..core_section import CoreSection      class _CoreSectionChecker(_ConfigChecker):        _ACCEPTED_REPOSITORY_TYPES: Set[str] = {\"filesystem\", \"sql\"}        def __init__(self, config: _Config, collector: IssueCollector):          super().__init__(config, collector)        def _check(self) -> IssueCollector:          if core_section := self._config._unique_sections.get(CoreSection.name):              self._check_repository_type(core_section)          return self._collector        def _check_repository_type(self, core_section: CoreSection):          value = core_section.repository_type          if value not in self._ACCEPTED_REPOSITORY_TYPES:              self._warning(                  core_section._REPOSITORY_TYPE_KEY,                  value,                  f'Value \"{value}\" for field {core_section._REPOSITORY_TYPE_KEY} of the CoreSection is not supported. '                  f'Default value \"filesystem\" is applied.',              ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from taipy.config._config import _Config  from taipy.config.checker._checkers._config_checker import _ConfigChecker  from taipy.config.checker.issue_collector import IssueCollector    from ..._version._version_manager_factory import _VersionManagerFactory  from ..migration_config import MigrationConfig      class _MigrationConfigChecker(_ConfigChecker):      def __init__(self, config: _Config, collector: IssueCollector):          super().__init__(config, collector)        def _check(self) -> IssueCollector:          if migration_config := self._config._unique_sections.get(MigrationConfig.name):              self._check_if_entity_property_key_used_is_predefined(migration_config)                migration_fcts = migration_config.migration_fcts                for target_version, migration_functions in migration_config.migration_fcts.items():                  for config_id, migration_function in migration_functions.items():                      self._check_callable(target_version, config_id, migration_function)                self._check_valid_production_version(migration_fcts)              self._check_migration_from_productions_to_productions_exist(migration_fcts)            return self._collector        def _check_callable(self, target_version, config_id, migration_function):          if not callable(migration_function):              self._error(                  MigrationConfig._MIGRATION_FCTS_KEY,                  migration_function,                  f\"The migration function of config `{config_id}` from version {target_version}\"                  f\" must be populated with Callable value.\",              )        def _check_valid_production_version(self, migration_fcts):          for target_version in migration_fcts.keys():              if target_version not in _VersionManagerFactory._build_manager()._get_production_versions():                  self._error(                      MigrationConfig._MIGRATION_FCTS_KEY,                      target_version,                      \"The target version for a migration function must be a production version.\",                  )        def _check_migration_from_productions_to_productions_exist(self, migration_fcts):          production_versions = _VersionManagerFactory._build_manager()._get_production_versions()          for source_version, target_version in zip(production_versions[:-1], production_versions[1:]):              if not migration_fcts.get(target_version):                  self._info(                      \"target_version\",                      None,                      f'There is no migration function from production version \"{source_version}\"'                      f' to version \"{target_version}\".',                  ) "}
{"text": "from typing import Dict    from taipy.config._config import _Config  from taipy.config.checker._checkers._config_checker import _ConfigChecker  from taipy.config.checker.issue_collector import IssueCollector    from ..data_node_config import DataNodeConfig  from ..job_config import JobConfig      class _JobConfigChecker(_ConfigChecker):      def __init__(self, config: _Config, collector: IssueCollector):          super().__init__(config, collector)        def _check(self) -> IssueCollector:          if job_config := self._config._unique_sections.get(JobConfig.name):              data_node_configs = self._config._sections[DataNodeConfig.name]              self._check_multiprocess_mode(job_config, data_node_configs)          return self._collector        def _check_multiprocess_mode(self, job_config: JobConfig, data_node_configs: Dict[str, DataNodeConfig]):          if job_config.is_standalone:              for cfg_id, data_node_config in data_node_configs.items():                  if data_node_config.storage_type == DataNodeConfig._STORAGE_TYPE_VALUE_IN_MEMORY:                      self._error(                          DataNodeConfig._STORAGE_TYPE_KEY,                          data_node_config.storage_type,                          f\"DataNode `{cfg_id}`: In-memory storage type can ONLY be used in \"                          f\"{JobConfig._DEVELOPMENT_MODE} mode.\",                      ) "}
{"text": "from typing import Dict, List    from taipy.config._config import _Config  from taipy.config.checker._checkers._config_checker import _ConfigChecker  from taipy.config.checker.issue_collector import IssueCollector      class _ConfigIdChecker(_ConfigChecker):      def __init__(self, config: _Config, collector: IssueCollector):          super().__init__(config, collector)        def _check(self) -> IssueCollector:          existing_config_ids: Dict[str, List[str]] = dict()          for entity_type, section_dictionary in self._config._sections.items():              for config_id in section_dictionary.keys():                  if config_id in existing_config_ids.keys():                      existing_config_ids[config_id].append(entity_type)                  else:                      existing_config_ids[config_id] = [entity_type]            for config_id, entity_types in existing_config_ids.items():              if config_id != \"default\" and len(entity_types) > 1:                  self._error(                      \"config_id\",                      config_id,                      f\"`{config_id}` is used as the config_id of multiple configurations {str(entity_types)}\",                  ) "}
{"text": "from taipy.config._config import _Config  from taipy.config.checker._checkers._config_checker import _ConfigChecker  from taipy.config.checker.issue_collector import IssueCollector    from ..data_node_config import DataNodeConfig  from ..task_config import TaskConfig      class _TaskConfigChecker(_ConfigChecker):      def __init__(self, config: _Config, collector: IssueCollector):          super().__init__(config, collector)        def _check(self) -> IssueCollector:          task_configs = self._config._sections[TaskConfig.name]          for task_config_id, task_config in task_configs.items():              if task_config_id != _Config.DEFAULT_KEY:                  self._check_existing_config_id(task_config)                  self._check_if_entity_property_key_used_is_predefined(task_config)                  self._check_existing_function(task_config_id, task_config)                  self._check_inputs(task_config_id, task_config)                  self._check_outputs(task_config_id, task_config)          return self._collector        def _check_inputs(self, task_config_id: str, task_config: TaskConfig):          self._check_children(              TaskConfig, task_config_id, task_config._INPUT_KEY, task_config.input_configs, DataNodeConfig          )        def _check_outputs(self, task_config_id: str, task_config: TaskConfig):          self._check_children(              TaskConfig, task_config_id, task_config._OUTPUT_KEY, task_config.output_configs, DataNodeConfig          )        def _check_existing_function(self, task_config_id: str, task_config: TaskConfig):          if not task_config.function:              self._error(                  task_config._FUNCTION,                  task_config.function,                  f\"{task_config._FUNCTION} field of TaskConfig `{task_config_id}` is empty.\",              )          else:              if not callable(task_config.function):                  self._error(                      task_config._FUNCTION,                      task_config.function,                      f\"{task_config._FUNCTION} field of TaskConfig `{task_config_id}` must be\"                      f\" populated with Callable value.\",                  ) "}
{"text": "from dataclasses import dataclass, field  from datetime import datetime  from functools import singledispatch  from typing import Any, Optional    from ..common._repr_enum import _ReprEnum  from ..exceptions.exceptions import InvalidEventAttributeName, InvalidEventOperation      class EventOperation(_ReprEnum):      \"\"\"Enum representing a type of operation performed on a Core entity.        `EventOperation` is used as an attribute of the `Event^` object to describe the      operation performed on an entity.<br>      The possible operations are `CREATION`, `UPDATE`, `DELETION`, or `SUBMISSION`.      \"\"\"        CREATION = 1      UPDATE = 2      DELETION = 3      SUBMISSION = 4      class EventEntityType(_ReprEnum):      \"\"\"Enum representing an entity type.        `EventEntityType` is used as an attribute of the `Event^` object to describe      an entity that was changed.<br>      The possible operations are `CYCLE`, `SCENARIO`, `SEQUENCE`, `TASK`, `DATA_NODE`, `JOB` or `SUBMISSION`.      \"\"\"        CYCLE = 1      SCENARIO = 2      SEQUENCE = 3      TASK = 4      DATA_NODE = 5      JOB = 6      SUBMISSION = 7      _NO_ATTRIBUTE_NAME_OPERATIONS = set([EventOperation.CREATION, EventOperation.DELETION, EventOperation.SUBMISSION])  _UNSUBMITTABLE_ENTITY_TYPES = (EventEntityType.CYCLE, EventEntityType.DATA_NODE, EventEntityType.JOB)  _ENTITY_TO_EVENT_ENTITY_TYPE = {      \"scenario\": EventEntityType.SCENARIO,      \"sequence\": EventEntityType.SEQUENCE,      \"task\": EventEntityType.TASK,      \"data\": EventEntityType.DATA_NODE,      \"job\": EventEntityType.JOB,      \"cycle\": EventEntityType.CYCLE,      \"submission\": EventEntityType.SUBMISSION,  }      @dataclass(frozen=True)  class Event:      \"\"\"Event object used to notify any change in the Core service.        An event holds the necessary attributes to identify the change.        Attributes:          entity_type (EventEntityType^): Type of the entity that was changed (`DataNode^`,              `Scenario^`, `Cycle^`, etc. ).          entity_id (Optional[str]): Unique identifier of the entity that was changed.          operation (EventOperation^): Enum describing the operation (among `CREATION`, `UPDATE`, `DELETION`,              and `SUBMISSION`) that was performed on the entity.          attribute_name (Optional[str]): Name of the entity's attribute changed. Only relevant for `UPDATE`              operations          attribute_value (Optional[str]): Name of the entity's attribute changed. Only relevant for `UPDATE`              operations          metadata (dict): A dict of additional medata about the source of this event          creation_date (datetime): Date and time of the event creation.      \"\"\"        entity_type: EventEntityType      operation: EventOperation      entity_id: Optional[str] = None      attribute_name: Optional[str] = None      attribute_value: Optional[Any] = None        metadata: dict = field(default_factory=dict)      creation_date: datetime = field(init=False)        def __post_init__(self):          # Creation date          super().__setattr__(\"creation_date\", datetime.now())            # Check operation:          if self.entity_type in _UNSUBMITTABLE_ENTITY_TYPES and self.operation == EventOperation.SUBMISSION:              raise InvalidEventOperation            # Check attribute name:          if self.operation in _NO_ATTRIBUTE_NAME_OPERATIONS and self.attribute_name is not None:              raise InvalidEventAttributeName      @singledispatch  def _make_event(      entity: Any,      operation: EventOperation,      /,      attribute_name: Optional[str] = None,      attribute_value: Optional[Any] = None,      **kwargs,  ) -> Event:      \"\"\"Helper function to make an event for this entity with the given `EventOperation^` type.      In case of `EventOperation.UPDATE^` events, an attribute name and value must be given.        Parameters:          entity (Any): The entity object to generate an event for.          operation (EventOperation^): The operation of the event. The possible values are:              <ul>                  <li>CREATION</li>                  <li>UPDATE</li>                  <li>DELETION</li>                  <li>SUBMISSION</li>              </ul>          attribute_name (Optional[str]): The name of the updated attribute for a `EventOperation.UPDATE`.              This argument is always given in case of an UPDATE.          attribute_value (Optional[Any]): The value of the udated attribute for a `EventOperation.UPDATE`.              This argument is always given in case of an UPDATE.          **kwargs (dict[str, any]): Any extra information that would be passed to the metadata event.              Note: you should pass only simple types: str, float, double as values.\"\"\"      raise Exception(f\"Unexpected entity type: {type(entity)}\") "}
{"text": "\"\"\"  Package for notifications about changes on `Core^` service entities.      The Core service generates `Event^` objects to track changes on entities.  These events are then relayed to a `Notifier^`, which handles the dispatch  to consumers interested in specific event topics.    To subscribe, a consumer needs to invoke the `Notifier.register()^` method.  This call will yield a `RegistrationId^` and a dedicated event queue for  receiving notifications.    To handle notifications, an event consumer (e.g., the `CoreEventConsumerBase^`  object) must be instantiated with an associated event queue.  \"\"\"    from ._registration import _Registration  from ._topic import _Topic  from .core_event_consumer import CoreEventConsumerBase  from .event import _ENTITY_TO_EVENT_ENTITY_TYPE, Event, EventEntityType, EventOperation, _make_event  from .notifier import Notifier, _publish_event  from .registration_id import RegistrationId "}
{"text": "from typing import NewType    RegistrationId = NewType(\"RegistrationId\", str)  RegistrationId.__doc__ = \"\"\"Registration identifier. It can be used to instantiate a `CoreEventConsumerBase^`.\"\"\" "}
{"text": "from queue import SimpleQueue  from typing import Optional  from uuid import uuid4    from ._topic import _Topic  from .event import EventEntityType, EventOperation  from .registration_id import RegistrationId      class _Registration:        _ID_PREFIX = \"REGISTRATION\"      __SEPARATOR = \"_\"        def __init__(          self,          entity_type: Optional[EventEntityType] = None,          entity_id: Optional[str] = None,          operation: Optional[EventOperation] = None,          attribute_name: Optional[str] = None,      ):            self.registration_id: str = self._new_id()          self.topic: _Topic = _Topic(entity_type, entity_id, operation, attribute_name)          self.queue: SimpleQueue = SimpleQueue()        @staticmethod      def _new_id() -> RegistrationId:          \"\"\"Generate a unique registration identifier.\"\"\"          return RegistrationId(_Registration.__SEPARATOR.join([_Registration._ID_PREFIX, str(uuid4())]))        def __hash__(self) -> int:          return hash(self.registration_id) "}
{"text": "from typing import Optional    from ..exceptions.exceptions import InvalidEventOperation  from .event import _UNSUBMITTABLE_ENTITY_TYPES, EventEntityType, EventOperation      class _Topic:      def __init__(          self,          entity_type: Optional[EventEntityType] = None,          entity_id: Optional[str] = None,          operation: Optional[EventOperation] = None,          attribute_name: Optional[str] = None,      ):            self.entity_type = entity_type          self.entity_id = entity_id          self.operation = self.__preprocess_operation(operation, self.entity_type)          self.attribute_name = self.__preprocess_attribute_name(attribute_name, self.operation)        @classmethod      def __preprocess_attribute_name(          cls, attribute_name: Optional[str] = None, operation: Optional[EventOperation] = None      ) -> Optional[str]:            # if operation in _NO_ATTRIBUTE_NAME_OPERATIONS and attribute_name is not None:          #     raise InvalidEventAttributeName          return attribute_name        @classmethod      def __preprocess_operation(          cls, operation: Optional[EventOperation] = None, entity_type: Optional[EventEntityType] = None      ) -> Optional[EventOperation]:          if (              entity_type              and operation              and entity_type in _UNSUBMITTABLE_ENTITY_TYPES              and operation == EventOperation.SUBMISSION          ):              raise InvalidEventOperation          return operation        def __hash__(self):          return hash((self.entity_type, self.entity_id, self.operation, self.attribute_name))        def __eq__(self, __value) -> bool:          if (              self.entity_type == __value.entity_type              and self.entity_id == __value.entity_id              and self.operation == __value.operation              and self.attribute_name == __value.attribute_name          ):              return True          return False "}
{"text": "import abc  import threading  from queue import Empty, SimpleQueue    from .event import Event      class CoreEventConsumerBase(threading.Thread):      \"\"\"Abstract base class for implementing a Core event consumer.        This class provides a framework for consuming events from a queue in a separate thread.      It should be subclassed, and the `process_event` method should be implemented to define      the custom logic for handling incoming events.        Example usage:        ```python      class MyEventConsumer(CoreEventConsumerBase):          def process_event(self, event: Event):              # Custom event processing logic here              print(f\"Received event created at : {event.creation_date}\")              pass        consumer = MyEventConsumer(\"consumer_1\", event_queue)      consumer.start()      # ...      consumer.stop()      ```        Subclasses should implement the `process_event` method to define their specific event handling behavior.        Attributes:          queue (SimpleQueue): The queue from which events will be consumed.          \"\"\"        def __init__(self, registration_id: str, queue: SimpleQueue):          \"\"\"Initialize a CoreEventConsumerBase instance.            Parameters:              registration_id (str): A unique identifier of the registration. You can get a                  registration id invoking `Notifier.register()^` method.              queue (SimpleQueue): The queue from which events will be consumed. You can get a                  queue invoking `Notifier.register()^` method.          \"\"\"          threading.Thread.__init__(self, name=f\"Thread-Taipy-Core-Consumer-{registration_id}\")          self.daemon = True          self.queue = queue          self.__STOP_FLAG = False          self._TIMEOUT = 0.1        def start(self):          \"\"\"Start the event consumer thread.\"\"\"          self.__STOP_FLAG = False          threading.Thread.start(self)        def stop(self):          \"\"\"Stop the event consumer thread.\"\"\"          self.__STOP_FLAG = True        def run(self):          while not self.__STOP_FLAG:              try:                  event: Event = self.queue.get(block=True, timeout=self._TIMEOUT)                  self.process_event(event)              except Empty:                  pass        @abc.abstractmethod      def process_event(self, event: Event):          \"\"\"This method should be overridden in subclasses to define how events are processed.\"\"\"          raise NotImplementedError "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._filesystem_repository import _FileSystemRepository  from ._cycle_converter import _CycleConverter  from ._cycle_model import _CycleModel      class _CycleFSRepository(_FileSystemRepository):      def __init__(self):          super().__init__(model_type=_CycleModel, converter=_CycleConverter, dir_name=\"cycles\") "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._sql_repository import _SQLRepository  from ._cycle_converter import _CycleConverter  from ._cycle_model import _CycleModel      class _CycleSQLRepository(_SQLRepository):      def __init__(self):          super().__init__(model_type=_CycleModel, converter=_CycleConverter) "}
{"text": "from typing import NewType    CycleId = NewType(\"CycleId\", str)  CycleId.__doc__ = \"\"\"Type that holds a `Cycle^` identifier.\"\"\" "}
{"text": "from dataclasses import dataclass  from typing import Any, Dict    from sqlalchemy import JSON, Column, Enum, String, Table    from taipy.config.common.frequency import Frequency    from .._repository._base_taipy_model import _BaseModel  from .._repository.db._sql_base_model import mapper_registry  from .cycle_id import CycleId      @mapper_registry.mapped  @dataclass  class _CycleModel(_BaseModel):      __table__ = Table(          \"cycle\",          mapper_registry.metadata,          Column(\"id\", String, primary_key=True),          Column(\"name\", String),          Column(\"frequency\", Enum(Frequency)),          Column(\"properties\", JSON),          Column(\"creation_date\", String),          Column(\"start_date\", String),          Column(\"end_date\", String),      )      id: CycleId      name: str      frequency: Frequency      properties: Dict[str, Any]      creation_date: str      start_date: str      end_date: str        @staticmethod      def from_dict(data: Dict[str, Any]):          return _CycleModel(              id=data[\"id\"],              name=data[\"name\"],              frequency=Frequency._from_repr(data[\"frequency\"]),              properties=_BaseModel._deserialize_attribute(data[\"properties\"]),              creation_date=data[\"creation_date\"],              start_date=data[\"start_date\"],              end_date=data[\"end_date\"],          )        def to_list(self):          return [              self.id,              self.name,              repr(self.frequency),              _BaseModel._serialize_attribute(self.properties),              self.creation_date,              self.start_date,              self.end_date,          ] "}
{"text": "from datetime import datetime    from .._repository._abstract_converter import _AbstractConverter  from ..cycle._cycle_model import _CycleModel  from ..cycle.cycle import Cycle      class _CycleConverter(_AbstractConverter):      @classmethod      def _entity_to_model(cls, cycle: Cycle) -> _CycleModel:          return _CycleModel(              id=cycle.id,              name=cycle._name,              frequency=cycle._frequency,              creation_date=cycle._creation_date.isoformat(),              start_date=cycle._start_date.isoformat(),              end_date=cycle._end_date.isoformat(),              properties=cycle._properties.data,          )        @classmethod      def _model_to_entity(cls, model: _CycleModel) -> Cycle:          return Cycle(              id=model.id,              name=model.name,              frequency=model.frequency,              properties=model.properties,              creation_date=datetime.fromisoformat(model.creation_date),              start_date=datetime.fromisoformat(model.start_date),              end_date=datetime.fromisoformat(model.end_date),          ) "}
{"text": "from typing import Type    from .._manager._manager_factory import _ManagerFactory  from ..common._utils import _load_fct  from ..cycle._cycle_manager import _CycleManager  from ._cycle_fs_repository import _CycleFSRepository  from ._cycle_sql_repository import _CycleSQLRepository      class _CycleManagerFactory(_ManagerFactory):        __REPOSITORY_MAP = {\"default\": _CycleFSRepository, \"sql\": _CycleSQLRepository}        @classmethod      def _build_manager(cls) -> Type[_CycleManager]:  # type: ignore          if cls._using_enterprise():              cycle_manager = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".cycle._cycle_manager\", \"_CycleManager\"              )  # type: ignore              build_repository = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".cycle._cycle_manager_factory\", \"_CycleManagerFactory\"              )._build_repository  # type: ignore          else:              cycle_manager = _CycleManager              build_repository = cls._build_repository          cycle_manager._repository = build_repository()  # type: ignore          return cycle_manager  # type: ignore        @classmethod      def _build_repository(cls):          return cls._get_repository_with_repo_map(cls.__REPOSITORY_MAP)() "}
{"text": "from abc import abstractmethod  from importlib import util  from typing import Type    from taipy.config import Config    from ._manager import _Manager      class _ManagerFactory:      _TAIPY_ENTERPRISE_MODULE = \"taipy.enterprise\"      _TAIPY_ENTERPRISE_CORE_MODULE = _TAIPY_ENTERPRISE_MODULE + \".core\"        @classmethod      @abstractmethod      def _build_manager(cls) -> Type[_Manager]:  # type: ignore          raise NotImplementedError        @classmethod      def _build_repository(cls):          raise NotImplementedError        @classmethod      def _using_enterprise(cls) -> bool:          return util.find_spec(cls._TAIPY_ENTERPRISE_MODULE) is not None        @staticmethod      def _get_repository_with_repo_map(repository_map: dict):          return repository_map.get(Config.core.repository_type, repository_map.get(\"default\")) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import pathlib  from importlib import metadata  from typing import Dict, Generic, Iterable, List, Optional, TypeVar, Union    from taipy.logger._taipy_logger import _TaipyLogger    from .._entity._entity_ids import _EntityIds  from .._repository._abstract_repository import _AbstractRepository  from ..exceptions.exceptions import ModelNotFound  from ..notification import Event, EventOperation, Notifier    EntityType = TypeVar(\"EntityType\")      class _Manager(Generic[EntityType]):      _repository: _AbstractRepository      _logger = _TaipyLogger._get_logger()      _ENTITY_NAME: str = \"Entity\"        @classmethod      def _delete_all(cls):          \"\"\"          Deletes all entities.          \"\"\"          cls._repository._delete_all()          if hasattr(cls, \"_EVENT_ENTITY_TYPE\"):              Notifier.publish(                  Event(                      cls._EVENT_ENTITY_TYPE,                      EventOperation.DELETION,                      metadata={\"delete_all\": True},                  )              )        @classmethod      def _delete_many(cls, ids: Iterable):          \"\"\"          Deletes entities by a list of ids.          \"\"\"          cls._repository._delete_many(ids)          if hasattr(cls, \"_EVENT_ENTITY_TYPE\"):              for entity_id in ids:                  Notifier.publish(                      Event(                          cls._EVENT_ENTITY_TYPE,  # type: ignore                          EventOperation.DELETION,                          entity_id=entity_id,                          metadata={\"delete_all\": True},                      )                  )        @classmethod      def _delete_by_version(cls, version_number: str):          \"\"\"          Deletes entities by version number.          \"\"\"          cls._repository._delete_by(attribute=\"version\", value=version_number)          if hasattr(cls, \"_EVENT_ENTITY_TYPE\"):              Notifier.publish(                  Event(                      cls._EVENT_ENTITY_TYPE,  # type: ignore                      EventOperation.DELETION,                      metadata={\"delete_by_version\": version_number},                  )              )        @classmethod      def _delete(cls, id):          \"\"\"          Deletes an entity by id.          \"\"\"          cls._repository._delete(id)          if hasattr(cls, \"_EVENT_ENTITY_TYPE\"):              Notifier.publish(                  Event(                      cls._EVENT_ENTITY_TYPE,                      EventOperation.DELETION,                      entity_id=id,                  )              )        @classmethod      def _set(cls, entity: EntityType):          \"\"\"          Save or update an entity.          \"\"\"          cls._repository._save(entity)        @classmethod      def _get_all(cls, version_number: Optional[str] = \"all\") -> List[EntityType]:          \"\"\"          Returns all entities.          \"\"\"          filters: List[Dict] = []          return cls._repository._load_all(filters)        @classmethod      def _get_all_by(cls, filters: Optional[List[Dict]] = None) -> List[EntityType]:          \"\"\"          Returns all entities based on a criteria.          \"\"\"          if not filters:              filters = []          return cls._repository._load_all(filters)        @classmethod      def _get(cls, entity: Union[str, EntityType], default=None) -> EntityType:          \"\"\"          Returns an entity by id or reference.          \"\"\"          entity_id = entity if isinstance(entity, str) else entity.id  # type: ignore          try:              return cls._repository._load(entity_id)          except ModelNotFound:              cls._logger.error(f\"{cls._ENTITY_NAME} not found: {entity_id}\")              return default        @classmethod      def _exists(cls, entity_id: str) -> bool:          \"\"\"          Returns True if the entity id exists.          \"\"\"          return cls._repository._exists(entity_id)        @classmethod      def _delete_entities_of_multiple_types(cls, _entity_ids: _EntityIds):          \"\"\"          Deletes entities of multiple types.          \"\"\"          from ..cycle._cycle_manager_factory import _CycleManagerFactory          from ..data._data_manager_factory import _DataManagerFactory          from ..job._job_manager_factory import _JobManagerFactory          from ..scenario._scenario_manager_factory import _ScenarioManagerFactory          from ..sequence._sequence_manager_factory import _SequenceManagerFactory          from ..submission._submission_manager_factory import _SubmissionManagerFactory          from ..task._task_manager_factory import _TaskManagerFactory            _CycleManagerFactory._build_manager()._delete_many(_entity_ids.cycle_ids)          _SequenceManagerFactory._build_manager()._delete_many(_entity_ids.sequence_ids)          _ScenarioManagerFactory._build_manager()._delete_many(_entity_ids.scenario_ids)          _TaskManagerFactory._build_manager()._delete_many(_entity_ids.task_ids)          _JobManagerFactory._build_manager()._delete_many(_entity_ids.job_ids)          _DataManagerFactory._build_manager()._delete_many(_entity_ids.data_node_ids)          _SubmissionManagerFactory._build_manager()._delete_many(_entity_ids.submission_ids)        @classmethod      def _export(cls, id: str, folder_path: Union[str, pathlib.Path]):          \"\"\"          Export an entity.          \"\"\"          return cls._repository._export(id, folder_path)        @classmethod      def _is_editable(cls, entity: Union[EntityType, _EntityIds]) -> bool:          return True        @classmethod      def _is_readable(cls, entity: Union[EntityType, _EntityIds]) -> bool:          return True "}
{"text": "from datetime import datetime  from typing import Any    from taipy.config import Config  from taipy.config._config import _Config    from .._entity._entity import _Entity      class _Version(_Entity):      def __init__(self, id: str, config: Any) -> None:          self.id: str = id          self.config: _Config = config          self.creation_date: datetime = datetime.now()        def __eq__(self, other):          return self.id == other.id and self.__is_config_eq(other)        def __is_config_eq(self, other):          return Config._serializer._str(self.config) == Config._serializer._str(other.config) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from typing import Dict, List    from .._version._version_manager_factory import _VersionManagerFactory      class _VersionMixin:        _version_manager = _VersionManagerFactory._build_manager()        @classmethod      def __fetch_version_number(cls, version_number):          version_number = _VersionManagerFactory._build_manager()._replace_version_number(version_number)            if not isinstance(version_number, List):              version_number = [version_number] if version_number else []          return version_number        @classmethod      def _build_filters_with_version(cls, version_number) -> List[Dict]:          filters = []          if versions := cls.__fetch_version_number(version_number):              filters = [{\"version\": version} for version in versions]          return filters        @classmethod      def _get_latest_version(cls):          return cls._version_manager._get_latest_version() "}
{"text": "from .._manager._manager_factory import _ManagerFactory  from ..common import _utils  from ._version_fs_repository import _VersionFSRepository  from ._version_manager import _VersionManager  from ._version_sql_repository import _VersionSQLRepository      class _VersionManagerFactory(_ManagerFactory):        __REPOSITORY_MAP = {\"default\": _VersionFSRepository, \"sql\": _VersionSQLRepository}        @classmethod      def _build_manager(cls) -> _VersionManager:  # type: ignore          if cls._using_enterprise():              version_manager = _utils._load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \"._version._version_manager\", \"_VersionManager\"              )  # type: ignore              build_repository = _utils._load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \"._version._version_manager_factory\", \"_VersionManagerFactory\"              )._build_repository  # type: ignore          else:              version_manager = _VersionManager              build_repository = cls._build_repository          version_manager._repository = build_repository()  # type: ignore          return version_manager  # type: ignore        @classmethod      def _build_repository(cls):          return cls._get_repository_with_repo_map(cls.__REPOSITORY_MAP)() "}
{"text": "from abc import ABC, abstractmethod      class _VersionRepositoryInterface(ABC):      _LATEST_VERSION_KEY = \"latest_version\"      _DEVELOPMENT_VERSION_KEY = \"development_version\"      _PRODUCTION_VERSION_KEY = \"production_version\"        @abstractmethod      def _set_latest_version(self, version_number):          raise NotImplementedError        @abstractmethod      def _get_latest_version(self):          raise NotImplementedError        @abstractmethod      def _set_development_version(self, version_number):          raise NotImplementedError        @abstractmethod      def _get_development_version(self):          raise NotImplementedError        @abstractmethod      def _set_production_version(self, version_number):          raise NotImplementedError        @abstractmethod      def _get_production_versions(self):          raise NotImplementedError        @abstractmethod      def _delete_production_version(self, version_number):          raise NotImplementedError "}
{"text": "import json  from typing import List    from taipy.logger._taipy_logger import _TaipyLogger    from .._repository._filesystem_repository import _FileSystemRepository  from ..exceptions.exceptions import VersionIsNotProductionVersion  from ._version_converter import _VersionConverter  from ._version_model import _VersionModel  from ._version_repository_interface import _VersionRepositoryInterface      class _VersionFSRepository(_FileSystemRepository, _VersionRepositoryInterface):      def __init__(self):          super().__init__(model_type=_VersionModel, converter=_VersionConverter, dir_name=\"version\")        @property      def _version_file_path(self):          return super()._storage_folder / \"version.json\"        def _delete_all(self):          super()._delete_all()            if self._version_file_path.exists():              self._version_file_path.unlink()        def _set_latest_version(self, version_number):          if self._version_file_path.exists():              with open(self._version_file_path, \"r\") as f:                  file_content = json.load(f)              file_content[self._LATEST_VERSION_KEY] = version_number          else:              self.dir_path.mkdir(parents=True, exist_ok=True)              file_content = {                  self._LATEST_VERSION_KEY: version_number,                  self._DEVELOPMENT_VERSION_KEY: \"\",                  self._PRODUCTION_VERSION_KEY: [],              }          self._version_file_path.write_text(              json.dumps(                  file_content,                  ensure_ascii=False,                  indent=0,              )          )        def _get_latest_version(self) -> str:          with open(self._version_file_path, \"r\") as f:              file_content = json.load(f)          return file_content[self._LATEST_VERSION_KEY]        def _set_development_version(self, version_number):          if self._version_file_path.exists():              with open(self._version_file_path, \"r\") as f:                  file_content = json.load(f)                file_content[self._DEVELOPMENT_VERSION_KEY] = version_number              file_content[self._LATEST_VERSION_KEY] = version_number          else:              self.dir_path.mkdir(parents=True, exist_ok=True)              file_content = {                  self._LATEST_VERSION_KEY: version_number,                  self._DEVELOPMENT_VERSION_KEY: version_number,                  self._PRODUCTION_VERSION_KEY: [],              }          self._version_file_path.write_text(              json.dumps(                  file_content,                  ensure_ascii=False,                  indent=0,              )          )        def _get_development_version(self) -> str:          with open(self._version_file_path, \"r\") as f:              file_content = json.load(f)          return file_content[self._DEVELOPMENT_VERSION_KEY]        def _set_production_version(self, version_number):          if self._version_file_path.exists():              with open(self._version_file_path, \"r\") as f:                  file_content = json.load(f)              file_content[self._LATEST_VERSION_KEY] = version_number              if version_number not in file_content[self._PRODUCTION_VERSION_KEY]:                  file_content[self._PRODUCTION_VERSION_KEY].append(version_number)              else:                  _TaipyLogger._get_logger().info(f\"Version {version_number} is already a production version.\")          else:              self.dir_path.mkdir(parents=True, exist_ok=True)              file_content = {                  self._LATEST_VERSION_KEY: version_number,                  self._DEVELOPMENT_VERSION_KEY: \"\",                  self._PRODUCTION_VERSION_KEY: [version_number],              }          self._version_file_path.write_text(              json.dumps(                  file_content,                  ensure_ascii=False,                  indent=0,              )          )        def _get_production_versions(self) -> List[str]:          with open(self._version_file_path, \"r\") as f:              file_content = json.load(f)          return file_content[self._PRODUCTION_VERSION_KEY]        def _delete_production_version(self, version_number):          try:              with open(self._version_file_path, \"r\") as f:                  file_content = json.load(f)              if version_number not in file_content[self._PRODUCTION_VERSION_KEY]:                  raise VersionIsNotProductionVersion(f\"Version '{version_number}' is not a production version.\")              file_content[self._PRODUCTION_VERSION_KEY].remove(version_number)              self._version_file_path.write_text(                  json.dumps(                      file_content,                      ensure_ascii=False,                      indent=0,                  )              )          except FileNotFoundError:              raise VersionIsNotProductionVersion(f\"Version '{version_number}' is not a production version.\") "}
{"text": "from sqlalchemy.dialects import sqlite    from .._repository._sql_repository import _SQLRepository  from ..exceptions.exceptions import ModelNotFound, VersionIsNotProductionVersion  from ._version_converter import _VersionConverter  from ._version_model import _VersionModel  from ._version_repository_interface import _VersionRepositoryInterface      class _VersionSQLRepository(_SQLRepository, _VersionRepositoryInterface):      def __init__(self):          super().__init__(model_type=_VersionModel, converter=_VersionConverter)        def _set_latest_version(self, version_number):          if old_latest := self.db.execute(str(self.table.select().filter_by(is_latest=True))).fetchone():              old_latest = self.model_type.from_dict(old_latest)              old_latest.is_latest = False              self._update_entry(old_latest)            version = self.__get_by_id(version_number)          version.is_latest = True          self._update_entry(version)        def _get_latest_version(self):          if latest := self.db.execute(              str(self.table.select().filter_by(is_latest=True).compile(dialect=sqlite.dialect()))          ).fetchone():              return latest[\"id\"]          raise ModelNotFound(self.model_type, \"\")        def _set_development_version(self, version_number):          if old_development := self.db.execute(str(self.table.select().filter_by(is_development=True))).fetchone():              old_development = self.model_type.from_dict(old_development)              old_development.is_development = False              self._update_entry(old_development)            version = self.__get_by_id(version_number)          version.is_development = True          self._update_entry(version)            self._set_latest_version(version_number)        def _get_development_version(self):          if development := self.db.execute(str(self.table.select().filter_by(is_development=True))).fetchone():              return development[\"id\"]          raise ModelNotFound(self.model_type, \"\")        def _set_production_version(self, version_number):          version = self.__get_by_id(version_number)          version.is_production = True          self._update_entry(version)            self._set_latest_version(version_number)        def _get_production_versions(self):          if productions := self.db.execute(              str(self.table.select().filter_by(is_production=True).compile(dialect=sqlite.dialect())),          ).fetchall():              return [p[\"id\"] for p in productions]          return []        def _delete_production_version(self, version_number):          version = self.__get_by_id(version_number)            if not version or not version.is_production:              raise VersionIsNotProductionVersion(f\"Version '{version_number}' is not a production version.\")          version.is_production = False          self._update_entry(version)        def __get_by_id(self, version_id):          query = str(self.table.select().filter_by(id=version_id).compile(dialect=sqlite.dialect()))          entry = self.db.execute(query, [version_id]).fetchone()          return self.model_type.from_dict(entry) if entry else None "}
{"text": "from datetime import datetime    from taipy.config import Config    from .._repository._abstract_converter import _AbstractConverter  from .._version._version import _Version  from .._version._version_model import _VersionModel      class _VersionConverter(_AbstractConverter):      @classmethod      def _entity_to_model(cls, version: _Version) -> _VersionModel:          return _VersionModel(              id=version.id, config=Config._to_json(version.config), creation_date=version.creation_date.isoformat()          )        @classmethod      def _model_to_entity(cls, model: _VersionModel) -> _Version:          version = _Version(id=model.id, config=Config._from_json(model.config))          version.creation_date = datetime.fromisoformat(model.creation_date)          return version "}
{"text": "from dataclasses import dataclass  from typing import Any, Dict    from sqlalchemy import Boolean, Column, String, Table    from .._repository._base_taipy_model import _BaseModel  from .._repository.db._sql_base_model import mapper_registry      @mapper_registry.mapped  @dataclass  class _VersionModel(_BaseModel):      __table__ = Table(          \"version\",          mapper_registry.metadata,          Column(\"id\", String, primary_key=True),          Column(\"config\", String),  # config is store as a json string          Column(\"creation_date\", String),          Column(\"is_production\", Boolean),          Column(\"is_development\", Boolean),          Column(\"is_latest\", Boolean),      )      id: str      config: Dict[str, Any]      creation_date: str        @staticmethod      def from_dict(data: Dict[str, Any]):          model = _VersionModel(              id=data[\"id\"],              config=data[\"config\"],              creation_date=data[\"creation_date\"],          )          model.is_production = data.get(\"is_production\")  # type: ignore          model.is_development = data.get(\"is_development\")  # type: ignore          model.is_latest = data.get(\"is_latest\")  # type: ignore          return model        def to_list(self):          return [              self.id,              self.config,              self.creation_date,              self.is_production,              self.is_development,              self.is_latest,          ] "}
{"text": "from typing import Callable, List    from taipy.config.config import Config    from .._entity._reload import _Reloader  from ..config import MigrationConfig  from ._version_manager_factory import _VersionManagerFactory      def _migrate_entity(entity):      if (          latest_version := _VersionManagerFactory._build_manager()._get_latest_version()      ) in _VersionManagerFactory._build_manager()._get_production_versions():          if migration_fcts := __get_migration_fcts_to_latest(entity._version, entity.config_id):              with _Reloader():                  for fct in migration_fcts:                      entity = fct(entity)                  entity._version = latest_version        return entity      def __get_migration_fcts_to_latest(source_version: str, config_id: str) -> List[Callable]:      migration_fcts_to_latest: List[Callable] = []        production_versions = _VersionManagerFactory._build_manager()._get_production_versions()      try:          start_index = production_versions.index(source_version) + 1      except ValueError:          return migration_fcts_to_latest        versions_to_migrate = production_versions[start_index:]        for version in versions_to_migrate:          migration_fct = Config.unique_sections[MigrationConfig.name].migration_fcts.get(version, {}).get(config_id)          if migration_fct:              migration_fcts_to_latest.append(migration_fct)        return migration_fcts_to_latest "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import os  import sys      def _vt_codes_enabled_in_windows_registry():      \"\"\"      Check the Windows Registry to see if VT code handling has been enabled      by default, see https://superuser.com/a/1300251/447564.      \"\"\"      try:          # winreg is only available on Windows.          import winreg      except ImportError:          return False      else:          try:              reg_key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, \"Console\")              reg_key_value, _ = winreg.QueryValueEx(reg_key, \"VirtualTerminalLevel\")          except FileNotFoundError:              return False          else:              return reg_key_value == 1      def _is_color_supported():      \"\"\"      Return True if the running system's terminal supports color,      and False otherwise.      \"\"\"        is_a_tty = hasattr(sys.stdout, \"isatty\") and sys.stdout.isatty()        return is_a_tty and (          sys.platform != \"win32\"          or \"ANSICON\" in os.environ          or \"WT_SESSION\" in os.environ  # Windows Terminal supports VT codes.          or os.environ.get(\"TERM_PROGRAM\") == \"vscode\"  # VSCode's built-in terminal supports colors.          or _vt_codes_enabled_in_windows_registry()      )      class _Bcolors:      PURPLE = \"\\033[95m\" if _is_color_supported() else \"\"      BLUE = \"\\033[94m\" if _is_color_supported() else \"\"      CYAN = \"\\033[96m\" if _is_color_supported() else \"\"      GREEN = \"\\033[92m\" if _is_color_supported() else \"\"      BOLD = \"\\033[1m\" if _is_color_supported() else \"\"      UNDERLINE = \"\\033[4m\" if _is_color_supported() else \"\"      END = \"\\033[0m\" if _is_color_supported() else \"\" "}
{"text": "from .exceptions import * "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from __future__ import annotations    import abc  from typing import Any, Callable, List, Optional, Set, Union    import networkx as nx    from ..common._listattributes import _ListAttributes  from ..common._utils import _Subscriber  from ..data.data_node import DataNode  from ..job.job import Job  from ..task.task import Task  from ._dag import _DAG      class Submittable:      \"\"\"Instance of an entity that can be submitted for execution.        A submittable holds functions that can be used to build the execution directed acyclic graph.        Attributes:          subscribers (List[Callable]): The list of callbacks to be called on `Job^`'s status change.      \"\"\"        def __init__(self, subscribers: Optional[List[_Subscriber]] = None):          self._subscribers = _ListAttributes(self, subscribers or list())        @abc.abstractmethod      def submit(          self,          callbacks: Optional[List[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,      ):          raise NotImplementedError        def get_inputs(self) -> Set[DataNode]:          \"\"\"Return the set of input data nodes of the submittable entity.            Returns:              The set of input data nodes.          \"\"\"          dag = self._build_dag()          return self.__get_inputs(dag)        def __get_inputs(self, dag: nx.DiGraph) -> Set[DataNode]:          return {node for node, degree in dict(dag.in_degree).items() if degree == 0 and isinstance(node, DataNode)}        def get_outputs(self) -> Set[DataNode]:          \"\"\"Return the set of output data nodes of the submittable entity.            Returns:              The set of output data nodes.          \"\"\"          dag = self._build_dag()          return self.__get_outputs(dag)        def __get_outputs(self, dag: nx.DiGraph) -> set[DataNode]:          return {node for node, degree in dict(dag.out_degree).items() if degree == 0 and isinstance(node, DataNode)}        def get_intermediate(self) -> Set[DataNode]:          \"\"\"Return the set of intermediate data nodes of the submittable entity.            Returns:              The set of intermediate data nodes.          \"\"\"          dag = self._build_dag()          all_data_nodes_in_dag = {node for node in dag.nodes if isinstance(node, DataNode)}          return all_data_nodes_in_dag - self.__get_inputs(dag) - self.__get_outputs(dag)        def is_ready_to_run(self) -> bool:          \"\"\"Indicate if the entity is ready to be run.            Returns:              True if the given entity is ready to be run. False otherwise.          \"\"\"          return all(dn.is_ready_for_reading for dn in self.get_inputs())        def data_nodes_being_edited(self) -> Set[DataNode]:          \"\"\"Return the set of data nodes of the submittable entity that are being edited.            Returns:              The set of data nodes that are being edited.          \"\"\"          dag = self._build_dag()          return {node for node in dag.nodes if isinstance(node, DataNode) and node.edit_in_progress}        @abc.abstractmethod      def subscribe(self, callback: Callable[[Submittable, Job], None], params: Optional[List[Any]] = None):          raise NotImplementedError        @abc.abstractmethod      def unsubscribe(self, callback: Callable[[Submittable, Job], None], params: Optional[List[Any]] = None):          raise NotImplementedError        @abc.abstractmethod      def _get_set_of_tasks(self) -> Set[Task]:          raise NotImplementedError        def _get_dag(self) -> _DAG:          return _DAG(self._build_dag())        def _build_dag(self) -> nx.DiGraph:          graph = nx.DiGraph()          tasks = self._get_set_of_tasks()          for task in tasks:              if has_input := task.input:                  for predecessor in task.input.values():                      graph.add_edges_from([(predecessor, task)])              if has_output := task.output:                  for successor in task.output.values():                      graph.add_edges_from([(task, successor)])              if not has_input and not has_output:                  graph.add_node(task)          return graph        def _get_sorted_tasks(self) -> List[List[Task]]:          dag = self._build_dag()          remove = [node for node, degree in dict(dag.in_degree).items() if degree == 0 and isinstance(node, DataNode)]          dag.remove_nodes_from(remove)          return list(nodes for nodes in nx.topological_generations(dag) if (Task in (type(node) for node in nodes)))        def _add_subscriber(self, callback: Callable, params: Optional[List[Any]] = None):          params = [] if params is None else params          self._subscribers.append(_Subscriber(callback=callback, params=params))        def _remove_subscriber(self, callback: Callable, params: Optional[List[Any]] = None):          if params is not None:              self._subscribers.remove(_Subscriber(callback, params))          else:              elem = [x for x in self._subscribers if x.callback == callback]              if not elem:                  raise ValueError              self._subscribers.remove(elem[0]) "}
{"text": "from typing import List    from .._entity._reload import _get_manager  from ..notification import Notifier      class _Entity:      _MANAGER_NAME: str      _is_in_context = False      _in_context_attributes_changed_collector: List        def __enter__(self):          self._is_in_context = True          self._in_context_attributes_changed_collector = list()          return self        def __exit__(self, exc_type, exc_value, exc_traceback):          # If multiple entities is in context, the last to enter will be the first to exit          self._is_in_context = False          if hasattr(self, \"_properties\"):              for to_delete_key in self._properties._pending_deletions:                  self._properties.data.pop(to_delete_key, None)              self._properties.data.update(self._properties._pending_changes)          _get_manager(self._MANAGER_NAME)._set(self)            for event in self._in_context_attributes_changed_collector:              Notifier.publish(event)          _get_manager(self._MANAGER_NAME)._set(self) "}
{"text": "from collections import UserDict    from ..notification import _ENTITY_TO_EVENT_ENTITY_TYPE, EventOperation, Notifier, _make_event      class _Properties(UserDict):      __PROPERTIES_ATTRIBUTE_NAME = \"properties\"        def __init__(self, entity_owner, **kwargs):          super().__init__(**kwargs)          self._entity_owner = entity_owner          self._pending_changes = {}          self._pending_deletions = set()        def __setitem__(self, key, value):          super(_Properties, self).__setitem__(key, value)          from ... import core as tp            if hasattr(self, \"_entity_owner\"):              event = _make_event(                  self._entity_owner,                  EventOperation.UPDATE,                  attribute_name=self.__PROPERTIES_ATTRIBUTE_NAME,                  attribute_value=value,              )              if not self._entity_owner._is_in_context:                  tp.set(self._entity_owner)                  Notifier.publish(event)              else:                  if key in self._pending_deletions:                      self._pending_deletions.remove(key)                  self._pending_changes[key] = value                  self._entity_owner._in_context_attributes_changed_collector.append(event)        def __getitem__(self, key):          from taipy.config.common._template_handler import _TemplateHandler as _tpl            return _tpl._replace_templates(super(_Properties, self).__getitem__(key))        def __delitem__(self, key):          super(_Properties, self).__delitem__(key)          from ... import core as tp            if hasattr(self, \"_entity_owner\"):              event = _make_event(                  self._entity_owner,                  EventOperation.UPDATE,                  attribute_name=self.__PROPERTIES_ATTRIBUTE_NAME,                  attribute_value=None,              )              if not self._entity_owner._is_in_context:                  tp.set(self._entity_owner)                  Notifier.publish(event)              else:                  self._pending_changes.pop(key, None)                  self._pending_deletions.add(key)                  self._entity_owner._in_context_attributes_changed_collector.append(event) "}
{"text": "from __future__ import annotations      class _EntityIds:      def __init__(self):          self.data_node_ids = set()          self.task_ids = set()          self.scenario_ids = set()          self.sequence_ids = set()          self.job_ids = set()          self.cycle_ids = set()          self.submission_ids = set()        def __add__(self, other: _EntityIds):          self.data_node_ids.update(other.data_node_ids)          self.task_ids.update(other.task_ids)          self.scenario_ids.update(other.scenario_ids)          self.sequence_ids.update(other.sequence_ids)          self.job_ids.update(other.job_ids)          self.cycle_ids.update(other.cycle_ids)          self.submission_ids.update(other.submission_ids)          return self        def __iadd__(self, other: _EntityIds):          self.__add__(other)          return self "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  import math  from functools import reduce  from typing import Any, Dict, List, Tuple    import networkx as nx      class _Node:      def __init__(self, entity: Any, x, y):          self.type = entity.__class__.__name__          self.entity = entity          self.x = x          self.y = y      class _Edge:      def __init__(self, src: _Node, dest: _Node):          self.src = src          self.dest = dest      class _DAG:      def __init__(self, dag: nx.DiGraph):          self._sorted_nodes = list(nodes for nodes in nx.topological_generations(dag))          self._length, self._width = self.__compute_size()          self._grid_length, self._grid_width = self.__compute_grid_size()          self._nodes = self.__compute_nodes()          self._edges = self.__compute_edges(dag)        @property      def width(self) -> int:          return self._width        @property      def length(self) -> int:          return self._length        @property      def nodes(self) -> Dict[str, _Node]:          return self._nodes        @property      def edges(self) -> List[_Edge]:          return self._edges        def __compute_size(self) -> Tuple[int, int]:          return len(self._sorted_nodes), max([len(i) for i in self._sorted_nodes])        def __compute_grid_size(self) -> Tuple[int, int]:          if self._width == 1:              grd_wdt = 1          else:              grd_wdt = self.__lcm(*[len(i) + 1 if len(i) != self._width else len(i) - 1 for i in self._sorted_nodes]) + 1          return len(self._sorted_nodes), grd_wdt        def __compute_nodes(self) -> Dict[str, _Node]:          nodes = {}          x = 0          for same_lvl_nodes in self._sorted_nodes:              lcl_wdt = len(same_lvl_nodes)              is_max = lcl_wdt != self.width              if self.width != 1:                  y_incr = (self._grid_width - 1) / (lcl_wdt + 1) if is_max else (self._grid_width - 1) / (lcl_wdt - 1)              else:                  y_incr = 1              y = 0 if is_max else -y_incr              for node in same_lvl_nodes:                  y += y_incr                  nodes[node.id] = _Node(node, x, y)              x += 1          return nodes        def __compute_edges(self, dag) -> List[_Edge]:          edges = []          for edge in dag.edges():              edges.append(_Edge(self.nodes[edge[0].id], self.nodes[edge[1].id]))          return edges        @staticmethod      def __lcm(*integers) -> int:          # Function math.lcm is only implemented for Python 3.9+          # For compatibility with Python 3.8 it has been re implemented.          if 0 in integers:              return 0          return reduce(lambda x, y: (x * y) // math.gcd(x, y), integers) "}
{"text": "import sys  from typing import List    from taipy._cli._base_cli import _CLI  from taipy.logger._taipy_logger import _TaipyLogger    from ._migrate import (      _migrate_fs_entities,      _migrate_mongo_entities,      _migrate_sql_entities,      _remove_backup_file_entities,      _remove_backup_mongo_entities,      _remove_backup_sql_entities,      _restore_migrate_file_entities,      _restore_migrate_mongo_entities,      _restore_migrate_sql_entities,  )      class _MigrateCLI:      __logger = _TaipyLogger._get_logger()        @classmethod      def create_parser(cls):          migrate_parser = _CLI._add_subparser(              \"migrate\",              help=\"Migrate entities created from old taipy versions to be compatible with the current taipy version. \"              \" The entity migration should be performed only after updating taipy code to the current version.\",          )          migrate_parser.add_argument(              \"--repository-type\",              required=True,              nargs=\"+\",              help=\"The type of repository to migrate. If filesystem or sql, a path to the database folder/.sqlite file \"              \"should be informed. In case of mongo host, port, user and password must be informed, if left empty it \"              \"is assumed default values\",          )          migrate_parser.add_argument(              \"--skip-backup\",              action=\"store_true\",              help=\"Skip the backup of entities before migration.\",          )          migrate_parser.add_argument(              \"--restore\",              action=\"store_true\",              help=\"Restore the migration of entities from backup folder.\",          )          migrate_parser.add_argument(              \"--remove-backup\",              action=\"store_true\",              help=\"Remove the backup of entities. Only use this option if the migration was successful.\",          )        @classmethod      def parse_arguments(cls):          args = _CLI._parse()            if getattr(args, \"which\", None) != \"migrate\":              return            repository_type = args.repository_type[0]          repository_args = args.repository_type[1:] if len(args.repository_type) > 1 else [None]            if args.restore:              cls.__handle_restore_backup(repository_type, repository_args)          if args.remove_backup:              cls.__handle_remove_backup(repository_type, repository_args)            do_backup = False if args.skip_backup else True          cls.__migrate_entities(repository_type, repository_args, do_backup)          sys.exit(0)        @classmethod      def __handle_remove_backup(cls, repository_type: str, repository_args: List):          if repository_type == \"filesystem\":              path = repository_args[0] or \".data\"              if not _remove_backup_file_entities(path):                  sys.exit(1)          elif repository_type == \"sql\":              if not _remove_backup_sql_entities(repository_args[0]):                  sys.exit(1)          elif repository_type == \"mongo\":              if not _remove_backup_mongo_entities():                  sys.exit(1)          else:              cls.__logger.error(f\"Unknown repository type {repository_type}\")              sys.exit(1)            sys.exit(0)        @classmethod      def __handle_restore_backup(cls, repository_type: str, repository_args: List):          if repository_type == \"filesystem\":              path = repository_args[0] or \".data\"              if not _restore_migrate_file_entities(path):                  sys.exit(1)          elif repository_type == \"sql\":              if not _restore_migrate_sql_entities(repository_args[0]):                  sys.exit(1)          elif repository_type == \"mongo\":              mongo_args = repository_args[1:5] if repository_args[0] else []              if not _restore_migrate_mongo_entities(*mongo_args):                  sys.exit(1)          else:              cls.__logger.error(f\"Unknown repository type {repository_type}\")              sys.exit(1)          sys.exit(0)        @classmethod      def __migrate_entities(cls, repository_type: str, repository_args: List, do_backup: bool):          if repository_type == \"filesystem\":              path = repository_args[0] or \".data\"              if not _migrate_fs_entities(path, do_backup):                  sys.exit(1)            elif repository_type == \"sql\":              if not _migrate_sql_entities(repository_args[0], do_backup):                  sys.exit(1)            elif repository_type == \"mongo\":              mongo_args = repository_args[1:5] if repository_args[0] else []              _migrate_mongo_entities(*mongo_args, backup=do_backup)  # type: ignore            else:              cls.__logger.error(f\"Unknown repository type {repository_type}\")              sys.exit(1) "}
{"text": "import functools    from ..notification import EventOperation, Notifier, _make_event      class _Reloader:      \"\"\"The _Reloader singleton class\"\"\"        _instance = None        _no_reload_context = False        def __new__(class_, *args, **kwargs):          if not isinstance(class_._instance, class_):              class_._instance = object.__new__(class_, *args, **kwargs)          return class_._instance        def _reload(self, manager: str, obj):          if self._no_reload_context:              return obj            entity = _get_manager(manager)._get(obj, obj)          if obj._is_in_context and hasattr(entity, \"_properties\"):              if obj._properties._pending_changes:                  entity._properties._pending_changes = obj._properties._pending_changes              if obj._properties._pending_deletions:                  entity._properties._pending_deletions = obj._properties._pending_deletions              entity._properties._entity_owner = obj          return entity        def __enter__(self):          self._no_reload_context = True          return self        def __exit__(self, exc_type, exc_value, exc_traceback):          self._no_reload_context = False      def _self_reload(manager):      def __reload(fct):          @functools.wraps(fct)          def _do_reload(self, *args, **kwargs):              self = _Reloader()._reload(manager, self)              return fct(self, *args, **kwargs)            return _do_reload        return __reload      def _self_setter(manager):      def __set_entity(fct):          @functools.wraps(fct)          def _do_set_entity(self, *args, **kwargs):              fct(self, *args, **kwargs)              entity_manager = _get_manager(manager)              if len(args) == 1:                  value = args[0]              else:                  value = args              event = _make_event(                  self,                  EventOperation.UPDATE,                  attribute_name=fct.__name__,                  attribute_value=value,              )              if not self._is_in_context:                  entity = _Reloader()._reload(manager, self)                  fct(entity, *args, **kwargs)                  entity_manager._set(entity)                  Notifier.publish(event)              else:                  self._in_context_attributes_changed_collector.append(event)            return _do_set_entity        return __set_entity      @functools.lru_cache  def _get_manager(manager: str):      from ..cycle._cycle_manager_factory import _CycleManagerFactory      from ..data._data_manager_factory import _DataManagerFactory      from ..job._job_manager_factory import _JobManagerFactory      from ..scenario._scenario_manager_factory import _ScenarioManagerFactory      from ..sequence._sequence_manager_factory import _SequenceManagerFactory      from ..submission._submission_manager_factory import _SubmissionManagerFactory      from ..task._task_manager_factory import _TaskManagerFactory        return {          \"scenario\": _ScenarioManagerFactory._build_manager(),          \"sequence\": _SequenceManagerFactory._build_manager(),          \"data\": _DataManagerFactory._build_manager(),          \"cycle\": _CycleManagerFactory._build_manager(),          \"job\": _JobManagerFactory._build_manager(),          \"task\": _TaskManagerFactory._build_manager(),          \"submission\": _SubmissionManagerFactory._build_manager(),      }[manager] "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  import abc  from typing import Optional      class _Labeled:      __LABEL_SEPARATOR = \" > \"        @abc.abstractmethod      def get_label(self) -> str:          raise NotImplementedError        def _get_label(self) -> str:          \"\"\"Returns the entity label made of the simple label prefixed by the owner label.            Returns:              The label of the entity as a string.          \"\"\"          return self._get_explicit_label() or self._generate_label()        @abc.abstractmethod      def get_simple_label(self) -> str:          raise NotImplementedError        def _get_simple_label(self) -> str:          \"\"\"Returns the simple label.            Returns:              The simple label of the entity as a string.          \"\"\"          return self._get_explicit_label() or self._generate_label(True)        def _generate_label(self, simple=False) -> str:          ls = []          if not simple:              if owner_id := self._get_owner_id():                  if getattr(self, \"id\") != owner_id:                      from ... import core as tp                        owner = tp.get(owner_id)                      ls.append(owner.get_label())          ls.append(self._generate_entity_label())          return self.__LABEL_SEPARATOR.join(ls)        def _get_explicit_label(self) -> Optional[str]:          if hasattr(self, \"_properties\"):              return getattr(self, \"_properties\").get(\"label\")          return None        def _get_owner_id(self) -> Optional[str]:          if hasattr(self, \"owner_id\"):              return getattr(self, \"owner_id\")          return None        def _get_name(self) -> Optional[str]:          if hasattr(self, \"name\"):              return getattr(self, \"name\")          if hasattr(self, \"_properties\"):              return getattr(self, \"_properties\").get(\"name\")          return None        def _get_config_id(self) -> Optional[str]:          if hasattr(self, \"config_id\"):              return getattr(self, \"config_id\")          return None        def _generate_entity_label(self) -> str:          if name := self._get_name():              return name          if config_id := self._get_config_id():              return config_id          return getattr(self, \"id\") "}
{"text": "import os  import shutil  from functools import lru_cache  from typing import Dict    import bson  import pymongo    from taipy.logger._taipy_logger import _TaipyLogger    from ._utils import _migrate    __logger = _TaipyLogger._get_logger()      OLD_COLLECTIONS = [      \"cycle\",      \"scenario\",      \"pipeline\",      \"task\",      \"data_node\",      \"job\",      \"version\",  ]  NEW_COLLECTIONS = [      \"cycle\",      \"scenario\",      \"task\",      \"data_node\",      \"job\",      \"version\",  ]  DATABASE_NAME = \"taipy\"  MONGO_BACKUP_FOLDER = \".mongo_backup\"      @lru_cache  def _connect_mongodb(db_host: str, db_port: int, db_username: str, db_password: str) -> pymongo.MongoClient:      auth_str = \"\"      if db_username and db_password:          auth_str = f\"{db_username}:{db_password}@\"        connection_string = f\"mongodb://{auth_str}{db_host}:{db_port}\"        return pymongo.MongoClient(connection_string)      def __load_all_entities_from_mongo(      hostname: str,      port: int,      user: str,      password: str,  ):      client = _connect_mongodb(hostname, port, user, password)      entities = {}      for collection in OLD_COLLECTIONS:          db = client[DATABASE_NAME]          cursor = db[collection].find({})          for document in cursor:              entities[document[\"id\"]] = {\"data\": document}        return entities      def __write_entities_to_mongo(      _entities: Dict,      hostname: str,      port: int,      user: str,      password: str,  ):      client = _connect_mongodb(hostname, port, user, password)      for collection in NEW_COLLECTIONS:          db = client[DATABASE_NAME]          db[collection].insert_many(              [entity[\"data\"] for entity in _entities.values() if collection in entity[\"data\"][\"id\"]]          )      def _backup_mongo_entities(      hostname: str = \"localhost\",      port: int = 27017,      user: str = \"\",      password: str = \"\",  ) -> bool:      client = _connect_mongodb(hostname, port, user, password)      db = client[DATABASE_NAME]        if not os.path.exists(MONGO_BACKUP_FOLDER):          os.makedirs(MONGO_BACKUP_FOLDER, exist_ok=True)        for collection in OLD_COLLECTIONS:          with open(os.path.join(MONGO_BACKUP_FOLDER, f\"{collection}.bson\"), \"wb+\") as f:              for doc in db[collection].find():                  f.write(bson.BSON.encode(doc))      __logger.info(f\"Backed up entities to folder '{MONGO_BACKUP_FOLDER}' before migration.\")      return True      def _restore_migrate_mongo_entities(      hostname: str = \"localhost\",      port: int = 27017,      user: str = \"\",      password: str = \"\",  ) -> bool:      client = _connect_mongodb(hostname, port, user, password)      db = client[DATABASE_NAME]        if not os.path.isdir(MONGO_BACKUP_FOLDER):          __logger.info(f\"The backup folder '{MONGO_BACKUP_FOLDER}' does not exist.\")          return False        for collection in os.listdir(MONGO_BACKUP_FOLDER):          if collection.endswith(\".bson\"):              with open(os.path.join(MONGO_BACKUP_FOLDER, collection), \"rb+\") as f:                  if bson_data := bson.decode_all(f.read()):  # type: ignore                      db[collection.split(\".\")[0]].insert_many(bson_data)        shutil.rmtree(MONGO_BACKUP_FOLDER)      __logger.info(f\"Restored entities from the backup folder '{MONGO_BACKUP_FOLDER}'.\")      return True      def _remove_backup_mongo_entities() -> bool:      if not os.path.isdir(MONGO_BACKUP_FOLDER):          __logger.info(f\"The backup folder '{MONGO_BACKUP_FOLDER}' does not exist.\")          return False        shutil.rmtree(MONGO_BACKUP_FOLDER)      __logger.info(f\"Removed backup entities from the backup folder '{MONGO_BACKUP_FOLDER}'.\")      return True      def _migrate_mongo_entities(      hostname: str = \"localhost\",      port: int = 27017,      user: str = \"\",      password: str = \"\",      backup: bool = True,  ) -> bool:      \"\"\"Migrate entities from mongodb to the current version.        Args:          hostname (str, optional): The hostname of the mongodb. Defaults to \"localhost\".          port (int, optional): The port of the mongodb. Defaults to 27017.          user (str, optional): The username of the mongodb. Defaults to \"\".          password (str, optional): The password of the mongodb. Defaults to \"\".          backup (bool, optional): Whether to backup the entities before migrating. Defaults to True.        Returns:          bool: True if the migration was successful, False otherwise.      \"\"\"      if backup:          _backup_mongo_entities(hostname=hostname, port=port, user=user, password=password)        __logger.info(f\"Starting entity migration from MongoDB {hostname}:{port}\")        entities = __load_all_entities_from_mongo(hostname, port, user, password)      entities, _ = _migrate(entities)      __write_entities_to_mongo(entities, hostname, port, user, password)        __logger.info(\"Migration finished\")      return True "}
{"text": "from ._migrate_fs import _migrate_fs_entities, _remove_backup_file_entities, _restore_migrate_file_entities  from ._migrate_mongo import _migrate_mongo_entities, _remove_backup_mongo_entities, _restore_migrate_mongo_entities  from ._migrate_sql import _migrate_sql_entities, _remove_backup_sql_entities, _restore_migrate_sql_entities "}
{"text": "import json  import os  import shutil  from typing import Dict    from taipy.logger._taipy_logger import _TaipyLogger    from ._utils import _migrate    __logger = _TaipyLogger._get_logger()      def _load_all_entities_from_fs(root: str) -> Dict:      # run through all files in the data folder and load them      entities = {}      for root, dirs, files in os.walk(root):          for file in files:              if file.endswith(\".json\"):                  with open(os.path.join(root, file)) as f:                      _id = file.split(\".\")[0]                      if \"version\" in root:                          _id = f\"VERSION_{_id}\"                      entities[_id] = {                          \"data\": json.load(f),                          \"path\": os.path.join(root, file),                      }      return entities      def __write_entities_to_fs(_entities: Dict, root: str):      if not os.path.exists(root):          os.makedirs(root, exist_ok=True)        for _id, entity in _entities.items():          # Do not write pipeline entities          if \"PIPELINE\" in _id:              continue          with open(entity[\"path\"], \"w\") as f:              json.dump(entity[\"data\"], f, indent=0)        # Remove pipelines folder      pipelines_path = os.path.join(root, \"pipelines\")      if os.path.exists(pipelines_path):          shutil.rmtree(pipelines_path)      def _restore_migrate_file_entities(path: str) -> bool:      backup_path = f\"{path}_backup\"        if not os.path.exists(backup_path):          __logger.error(f\"The backup folder '{backup_path}' does not exist.\")          return False        if os.path.exists(path):          shutil.rmtree(path)      else:          __logger.warning(f\"The original entities folder '{path}' does not exist.\")        os.rename(backup_path, path)      __logger.info(f\"Restored entities from the backup folder '{backup_path}' to '{path}'.\")      return True      def _remove_backup_file_entities(path: str) -> bool:      backup_path = f\"{path}_backup\"      if not os.path.exists(backup_path):          __logger.error(f\"The backup folder '{backup_path}' does not exist.\")          return False        shutil.rmtree(backup_path)      __logger.info(f\"Removed backup entities from the backup folder '{backup_path}'.\")      return True      def _migrate_fs_entities(path: str, backup: bool = True) -> bool:      \"\"\"Migrate entities from filesystem to the current version.        Args:          path (str): The path to the folder containing the entities.          backup (bool, optional): Whether to backup the entities before migrating. Defaults to True.        Returns:          bool: True if the migration was successful, False otherwise.      \"\"\"      if not os.path.isdir(path):          __logger.error(f\"Folder '{path}' does not exist.\")          return False        if backup:          backup_path = f\"{path}_backup\"          try:              shutil.copytree(path, backup_path)          except FileExistsError:              __logger.warning(f\"The backup folder '{backup_path}' already exists. Migration canceled.\")              return False          else:              __logger.info(f\"Backed up entities from '{path}' to '{backup_path}' folder before migration.\")        __logger.info(f\"Starting entity migration from '{path}' folder.\")        entities = _load_all_entities_from_fs(path)      entities, _ = _migrate(entities)      __write_entities_to_fs(entities, path)        __logger.info(\"Migration finished\")      return True "}
{"text": "from functools import lru_cache    import pymongo      @lru_cache  def _connect_mongodb(      db_host: str, db_port: int, db_username: str, db_password: str, db_extra_args: frozenset, db_driver: str  ) -> pymongo.MongoClient:      \"\"\"Create a connection to a Mongo database.      The `\"mongodb_extra_args\"` passed by the user is originally a dictionary, but since `@lru_cache` wrapper only      accepts hashable parameters, the `\"mongodb_extra_args\"` should be converted into a frozenset beforehand.        Parameters:          db_host (str): the database host.          db_port (int): the database port.          db_username (str): the database username.          db_password (str): the database password.          db_extra_args (frozenset): A frozenset converted from a dictionary of additional arguments to be passed into              database connection string.      Returns:          pymongo.MongoClient      \"\"\"      auth_str = \"\"      if db_username and db_password:          auth_str = f\"{db_username}:{db_password}@\"        extra_args_str = \"&\".join(f\"{k}={str(v)}\" for k, v in db_extra_args)      if extra_args_str:          extra_args_str = \"/?\" + extra_args_str        driver = \"mongodb\"      if db_driver:          driver = f\"{driver}+{db_driver}\"        connection_string = f\"{driver}://{auth_str}{db_host}\"      connection_string = connection_string if db_driver else f\"{connection_string}:{db_port}\"      connection_string += extra_args_str        return pymongo.MongoClient(connection_string) "}
{"text": "from taipy.config.common._validate_id import _validate_id      class MongoDefaultDocument:      \"\"\"The default class for \\\"custom_document\\\" property to configure a `MongoCollectionDataNode^`.        Attributes:          **kwargs: Attributes of the MongoDefaultDocument object.        Example:          - `document = MongoDefaultDocument(name=\"example\", age=30})`          will return a MongoDefaultDocument object so that `document.name` returns `\"example\"`,          and `document.age` returns `30`.          - `document = MongoDefaultDocument(date=\"12/24/2018\", temperature=20})`          will return a MongoDefaultDocument object so that `document.date` returns `\"12/24/2018\"`,          and `document.temperature` returns `20`.      \"\"\"        def __init__(self, **kwargs):          for attribute_name, value in kwargs.items():              setattr(self, _validate_id(attribute_name), value) "}
{"text": "from .mongo_default_document import MongoDefaultDocument "}
{"text": "from collections import UserList      class _ListAttributes(UserList):      def __init__(self, parent, *args, **kwargs):          super().__init__(*args, **kwargs)          self._parent = parent        def __add_iterable(self, iterable):          for i in iterable:              super(_ListAttributes, self).append(i)        def __set_self(self):          from ... import core as tp            if hasattr(self, \"_parent\"):              tp.set(self._parent)        def __add__(self, value):          if hasattr(value, \"__iter__\"):              self.__add_iterable(value)          else:              self.append(value)          return self        def extend(self, value) -> None:          super(_ListAttributes, self).extend(value)          self.__set_self()        def append(self, value) -> None:          super(_ListAttributes, self).append(value)          self.__set_self()        def remove(self, value):          super(_ListAttributes, self).remove(value)          self.__set_self()        def clear(self) -> None:          super(_ListAttributes, self).clear()          self.__set_self() "}
{"text": "import functools  import warnings  from typing import Optional    warnings.simplefilter(\"once\", ResourceWarning)      def _warn_deprecated(deprecated: str, suggest: Optional[str] = None, stacklevel: int = 3) -> None:      category = DeprecationWarning      message = f\"{deprecated} is deprecated.\"      if suggest:          message += f\" Use {suggest} instead.\"      warnings.warn(message=message, category=category, stacklevel=stacklevel)      def _warn_no_core_service(stacklevel: int = 3):      def inner(f):          @functools.wraps(f)          def _check_if_core_service_is_running(*args, **kwargs):              from .._orchestrator._orchestrator_factory import _OrchestratorFactory                if not _OrchestratorFactory._dispatcher:                  message = \"The Core service is NOT running\"                  warnings.warn(message=message, category=ResourceWarning, stacklevel=stacklevel)                return f(*args, **kwargs)            return _check_if_core_service_is_running        return inner "}
{"text": "import functools  from enum import Enum      class _ReprEnum(Enum):      @classmethod      @functools.lru_cache      def _from_repr(cls, repr_: str):          return next(filter(lambda e: repr(e) == repr_, cls))  # type: ignore "}
{"text": "from typing import Iterable    from taipy.logger._taipy_logger import _TaipyLogger    from ..data import DataNode      def _warn_if_inputs_not_ready(inputs: Iterable[DataNode]):      from ..data import CSVDataNode, ExcelDataNode, JSONDataNode, ParquetDataNode, PickleDataNode      from ..data._data_manager_factory import _DataManagerFactory        logger = _TaipyLogger._get_logger()      data_manager = _DataManagerFactory._build_manager()      for dn in inputs:          dn = data_manager._get(dn.id)          if dn.is_ready_for_reading is False and not dn._last_edit_date:              if dn.storage_type() in [                  CSVDataNode.storage_type(),                  ExcelDataNode.storage_type(),                  JSONDataNode.storage_type(),                  PickleDataNode.storage_type(),                  ParquetDataNode.storage_type(),              ]:                  logger.warning(                      f\"{dn.id} cannot be read because it has never been written. \"                      f\"Hint: The data node may refer to a wrong path : {dn.path} \"                  )              else:                  logger.warning(f\"{dn.id} cannot be read because it has never been written.\") "}
{"text": "from typing import TypeVar, Union    from .._repository._abstract_converter import _AbstractConverter  from .._repository._base_taipy_model import _BaseModel    ModelType = TypeVar(\"ModelType\", bound=_BaseModel)  Entity = TypeVar(\"Entity\")  Converter = TypeVar(\"Converter\", bound=_AbstractConverter)  Json = Union[dict, list, str, int, float, bool] "}
{"text": "import functools  import time  from collections import namedtuple  from importlib import import_module  from operator import attrgetter  from typing import Callable, Optional, Tuple    from taipy.config import Config      @functools.lru_cache  def _load_fct(module_name: str, fct_name: str) -> Callable:      module = import_module(module_name)      return attrgetter(fct_name)(module)      def _retry_read_entity(exceptions: Tuple, sleep_time: float = 0.2):      \"\"\"      Retries the wrapped function/method if the exceptions listed      in ``exceptions`` are thrown.      The number of retries is defined by Config.core.read_entity_retry.        Parameters:          exceptions (tuple): Tuple of exceptions that trigger a retry attempt.          sleep_time (float): Time to sleep between retries.      \"\"\"        def decorator(func):          def newfn(*args, **kwargs):              for _ in range(Config.core.read_entity_retry):                  try:                      return func(*args, **kwargs)                  except exceptions:                      time.sleep(sleep_time)              return func(*args, **kwargs)            return newfn        return decorator      @functools.lru_cache  def _get_fct_name(f) -> Optional[str]:      # Mock function does not have __qualname__ attribute -> return __name__      # Partial or anonymous function does not have __name__ or __qualname__ attribute -> return None      name = getattr(f, \"__qualname__\", getattr(f, \"__name__\", None))      return name      def _fct_to_dict(obj):      params = []      callback = obj        if isinstance(obj, _Subscriber):          callback = obj.callback          params = obj.params        fct_name = _get_fct_name(callback)      if not fct_name:          return None      return {          \"fct_name\": fct_name,          \"fct_params\": params,          \"fct_module\": callback.__module__,      }      def _fcts_to_dict(objs):      return [d for obj in objs if (d := _fct_to_dict(obj)) is not None]      _Subscriber = namedtuple(\"_Subscriber\", \"callback params\") "}
{"text": "from typing import Type    from .._manager._manager_factory import _ManagerFactory  from ..common._utils import _load_fct  from ._scenario_fs_repository import _ScenarioFSRepository  from ._scenario_manager import _ScenarioManager  from ._scenario_sql_repository import _ScenarioSQLRepository      class _ScenarioManagerFactory(_ManagerFactory):        __REPOSITORY_MAP = {\"default\": _ScenarioFSRepository, \"sql\": _ScenarioSQLRepository}        @classmethod      def _build_manager(cls) -> Type[_ScenarioManager]:  # type: ignore          if cls._using_enterprise():              scenario_manager = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".scenario._scenario_manager\", \"_ScenarioManager\"              )  # type: ignore              build_repository = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".scenario._scenario_manager_factory\", \"_ScenarioManagerFactory\"              )._build_repository  # type: ignore          else:              scenario_manager = _ScenarioManager              build_repository = cls._build_repository          scenario_manager._repository = build_repository()  # type: ignore          return scenario_manager  # type: ignore        @classmethod      def _build_repository(cls):          return cls._get_repository_with_repo_map(cls.__REPOSITORY_MAP)() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from dataclasses import dataclass  from typing import Any, Dict, List, Optional    from sqlalchemy import JSON, Boolean, Column, String, Table    from .._repository._base_taipy_model import _BaseModel  from .._repository.db._sql_base_model import mapper_registry  from ..cycle.cycle_id import CycleId  from ..data.data_node_id import DataNodeId  from ..task.task_id import TaskId  from .scenario_id import ScenarioId      @mapper_registry.mapped  @dataclass  class _ScenarioModel(_BaseModel):      __table__ = Table(          \"scenario\",          mapper_registry.metadata,          Column(\"id\", String, primary_key=True),          Column(\"config_id\", String),          Column(\"tasks\", JSON),          Column(\"additional_data_nodes\", JSON),          Column(\"properties\", JSON),          Column(\"creation_date\", String),          Column(\"primary_scenario\", Boolean),          Column(\"subscribers\", JSON),          Column(\"tags\", JSON),          Column(\"version\", String),          Column(\"sequences\", JSON),          Column(\"cycle\", String),      )      id: ScenarioId      config_id: str      tasks: List[TaskId]      additional_data_nodes: List[DataNodeId]      properties: Dict[str, Any]      creation_date: str      primary_scenario: bool      subscribers: List[Dict]      tags: List[str]      version: str      sequences: Optional[Dict[str, Dict]] = None      cycle: Optional[CycleId] = None        @staticmethod      def from_dict(data: Dict[str, Any]):          return _ScenarioModel(              id=data[\"id\"],              config_id=data[\"config_id\"],              tasks=_BaseModel._deserialize_attribute(data[\"tasks\"]),              additional_data_nodes=_BaseModel._deserialize_attribute(data[\"additional_data_nodes\"]),              properties=_BaseModel._deserialize_attribute(data[\"properties\"]),              creation_date=data[\"creation_date\"],              primary_scenario=data[\"primary_scenario\"],              subscribers=_BaseModel._deserialize_attribute(data[\"subscribers\"]),              tags=_BaseModel._deserialize_attribute(data[\"tags\"]),              version=data[\"version\"],              sequences=_BaseModel._deserialize_attribute(data[\"sequences\"]),              cycle=CycleId(data[\"cycle\"]) if \"cycle\" in data else None,          )        def to_list(self):          return [              self.id,              self.config_id,              _BaseModel._serialize_attribute(self.tasks),              _BaseModel._serialize_attribute(self.additional_data_nodes),              _BaseModel._serialize_attribute(self.properties),              self.creation_date,              self.primary_scenario,              _BaseModel._serialize_attribute(self.subscribers),              _BaseModel._serialize_attribute(self.tags),              self.version,              _BaseModel._serialize_attribute(self.sequences),              self.cycle,          ] "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._filesystem_repository import _FileSystemRepository  from ._scenario_converter import _ScenarioConverter  from ._scenario_model import _ScenarioModel      class _ScenarioFSRepository(_FileSystemRepository):      def __init__(self):          super().__init__(model_type=_ScenarioModel, converter=_ScenarioConverter, dir_name=\"scenarios\") "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._sql_repository import _SQLRepository  from ._scenario_converter import _ScenarioConverter  from ._scenario_model import _ScenarioModel      class _ScenarioSQLRepository(_SQLRepository):      def __init__(self):          super().__init__(model_type=_ScenarioModel, converter=_ScenarioConverter) "}
{"text": "from datetime import datetime  from typing import Dict, List, Optional, Set, Union    from .._repository._abstract_converter import _AbstractConverter  from .._version._utils import _migrate_entity  from ..common import _utils  from ..cycle._cycle_manager_factory import _CycleManagerFactory  from ..cycle.cycle import Cycle, CycleId  from ..data.data_node import DataNode, DataNodeId  from ..scenario._scenario_model import _ScenarioModel  from ..scenario.scenario import Scenario  from ..task.task import Task, TaskId      class _ScenarioConverter(_AbstractConverter):      @classmethod      def _entity_to_model(cls, scenario: Scenario) -> _ScenarioModel:          sequences: Dict[str, Dict[str, Union[List[TaskId], Dict, List]]] = {}          for p_name, sequence_data in scenario._sequences.items():              sequences[p_name] = {                  Scenario._SEQUENCE_TASKS_KEY: [                      t.id if isinstance(t, Task) else t for t in sequence_data.get(\"tasks\", [])                  ],                  Scenario._SEQUENCE_PROPERTIES_KEY: sequence_data.get(\"properties\", {}),                  Scenario._SEQUENCE_SUBSCRIBERS_KEY: _utils._fcts_to_dict(sequence_data.get(\"subscribers\", [])),              }            return _ScenarioModel(              id=scenario.id,              config_id=scenario.config_id,              tasks=[task.id if isinstance(task, Task) else TaskId(str(task)) for task in list(scenario._tasks)],              additional_data_nodes=[                  dn.id if isinstance(dn, DataNode) else DataNodeId(str(dn))                  for dn in list(scenario._additional_data_nodes)              ],              properties=scenario._properties.data,              creation_date=scenario._creation_date.isoformat(),              primary_scenario=scenario._primary_scenario,              subscribers=_utils._fcts_to_dict(scenario._subscribers),              tags=list(scenario._tags),              version=scenario._version,              cycle=scenario._cycle.id if scenario._cycle else None,              sequences=sequences if sequences else None,          )        @classmethod      def _model_to_entity(cls, model: _ScenarioModel) -> Scenario:          tasks: Union[Set[TaskId], Set[Task], Set] = set()          if model.tasks:              tasks = set(model.tasks)          if model.sequences:              for sequence_name, sequence_data in model.sequences.items():                  if subscribers := sequence_data.get(Scenario._SEQUENCE_SUBSCRIBERS_KEY):                      model.sequences[sequence_name][Scenario._SEQUENCE_SUBSCRIBERS_KEY] = [                          _utils._Subscriber(_utils._load_fct(it[\"fct_module\"], it[\"fct_name\"]), it[\"fct_params\"])                          for it in subscribers                      ]            scenario = Scenario(              scenario_id=model.id,              config_id=model.config_id,              tasks=tasks,              additional_data_nodes=set(model.additional_data_nodes),              properties=model.properties,              creation_date=datetime.fromisoformat(model.creation_date),              is_primary=model.primary_scenario,              tags=set(model.tags),              cycle=cls.__to_cycle(model.cycle),              subscribers=[                  _utils._Subscriber(_utils._load_fct(it[\"fct_module\"], it[\"fct_name\"]), it[\"fct_params\"])                  for it in model.subscribers              ],              version=model.version,              sequences=model.sequences,          )          return _migrate_entity(scenario)        @staticmethod      def __to_cycle(cycle_id: Optional[CycleId] = None) -> Optional[Cycle]:          return _CycleManagerFactory._build_manager()._get(cycle_id) if cycle_id else None "}
{"text": "from typing import NewType    ScenarioId = NewType(\"ScenarioId\", str)  ScenarioId.__doc__ = \"\"\"Type that holds a `Scenario^` identifier.\"\"\" "}
{"text": "from abc import abstractmethod  from typing import Callable, Iterable, List, Optional, Union    from ..job.job import Job  from ..task.task import Task      class _AbstractOrchestrator:      \"\"\"Creates, enqueues, and orchestrates jobs as instances of `Job^` class.\"\"\"        @classmethod      @abstractmethod      def initialize(cls):          raise NotImplementedError        @classmethod      @abstractmethod      def submit(          cls,          sequence,          callbacks: Optional[Iterable[Callable]],          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,      ) -> List[Job]:          raise NotImplementedError        @classmethod      @abstractmethod      def submit_task(          cls,          task: Task,          callbacks: Optional[Iterable[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,      ) -> Job:          raise NotImplementedError        @classmethod      @abstractmethod      def cancel_job(cls, job):          raise NotImplementedError "}
{"text": "from importlib import util  from typing import Optional, Type    from taipy.config.config import Config    from ..common._utils import _load_fct  from ..exceptions.exceptions import ModeNotAvailable, OrchestratorNotBuilt  from ._abstract_orchestrator import _AbstractOrchestrator  from ._dispatcher import _DevelopmentJobDispatcher, _JobDispatcher, _StandaloneJobDispatcher  from ._orchestrator import _Orchestrator      class _OrchestratorFactory:      _TAIPY_ENTERPRISE_MODULE = \"taipy.enterprise\"      _TAIPY_ENTERPRISE_CORE_ORCHESTRATOR_MODULE = _TAIPY_ENTERPRISE_MODULE + \".core._orchestrator._orchestrator\"      _TAIPY_ENTERPRISE_CORE_DISPATCHER_MODULE = _TAIPY_ENTERPRISE_MODULE + \".core._orchestrator._dispatcher\"      __TAIPY_ENTERPRISE_BUILD_DISPATCHER_METHOD = \"_build_dispatcher\"        _orchestrator: Optional[_Orchestrator] = None      _dispatcher: Optional[_JobDispatcher] = None        @classmethod      def _build_orchestrator(cls) -> Type[_AbstractOrchestrator]:          if util.find_spec(cls._TAIPY_ENTERPRISE_MODULE) is not None:              cls._orchestrator = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_ORCHESTRATOR_MODULE,                  \"Orchestrator\",              )  # type: ignore          else:              cls._orchestrator = _Orchestrator  # type: ignore            cls._orchestrator.initialize()  # type: ignore            return cls._orchestrator  # type: ignore        @classmethod      def _build_dispatcher(cls, force_restart=False) -> Optional[_JobDispatcher]:          if not cls._orchestrator:              raise OrchestratorNotBuilt          if Config.job_config.is_standalone:              cls.__build_standalone_job_dispatcher(force_restart=force_restart)          elif Config.job_config.is_development:              cls.__build_development_job_dispatcher()          elif util.find_spec(cls._TAIPY_ENTERPRISE_MODULE):              cls.__build_enterprise_job_dispatcher(force_restart=force_restart)          else:              raise ModeNotAvailable(f\"Job mode {Config.job_config.mode} is not available.\")          return cls._dispatcher        @classmethod      def _remove_dispatcher(cls) -> Optional[_JobDispatcher]:          if cls._dispatcher is not None and not isinstance(cls._dispatcher, _DevelopmentJobDispatcher):              cls._dispatcher.stop()          cls._dispatcher = None          return cls._dispatcher        @classmethod      def __build_standalone_job_dispatcher(cls, force_restart=False):          if isinstance(cls._dispatcher, _StandaloneJobDispatcher):              if force_restart:                  cls._dispatcher.stop()              else:                  return            if util.find_spec(cls._TAIPY_ENTERPRISE_MODULE) is not None:              cls._dispatcher = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_DISPATCHER_MODULE, cls.__TAIPY_ENTERPRISE_BUILD_DISPATCHER_METHOD              )(cls._orchestrator)          else:              cls._dispatcher = _StandaloneJobDispatcher(cls._orchestrator)  # type: ignore          cls._dispatcher.start()  # type: ignore        @classmethod      def __build_development_job_dispatcher(cls):          if isinstance(cls._dispatcher, _StandaloneJobDispatcher):              cls._dispatcher.stop()          cls._dispatcher = _DevelopmentJobDispatcher(cls._orchestrator)  # type: ignore        @classmethod      def __build_enterprise_job_dispatcher(cls, force_restart=False):          cls._dispatcher = _load_fct(              cls._TAIPY_ENTERPRISE_CORE_DISPATCHER_MODULE, cls.__TAIPY_ENTERPRISE_BUILD_DISPATCHER_METHOD          )(cls._orchestrator, force_restart)          if cls._dispatcher:              cls._dispatcher.start()          else:              raise ModeNotAvailable(f\"Job mode {Config.job_config.mode} is not available.\") "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from ._development_job_dispatcher import _DevelopmentJobDispatcher  from ._job_dispatcher import _JobDispatcher  from ._standalone_job_dispatcher import _StandaloneJobDispatcher "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from typing import Optional    from ...job.job import Job  from .._abstract_orchestrator import _AbstractOrchestrator  from ._job_dispatcher import _JobDispatcher  from ._task_function_wrapper import _TaskFunctionWrapper      class _DevelopmentJobDispatcher(_JobDispatcher):      \"\"\"Manages job dispatching (instances of `Job^` class) in a synchronous way.\"\"\"        def __init__(self, orchestrator: Optional[_AbstractOrchestrator]):          super().__init__(orchestrator)        def start(self):          raise NotImplementedError        def is_running(self) -> bool:          return True        def stop(self):          raise NotImplementedError        def run(self):          raise NotImplementedError        def _dispatch(self, job: Job):          \"\"\"Dispatches the given `Job^` on an available worker for execution.            Parameters:              job (Job^): The job to submit on an executor with an available worker.          \"\"\"          rs = _TaskFunctionWrapper(job.id, job.task).execute()          self._update_job_status(job, rs) "}
{"text": "from concurrent.futures import ProcessPoolExecutor  from functools import partial  from typing import Optional    from taipy.config._serializer._toml_serializer import _TomlSerializer  from taipy.config.config import Config    from ...job.job import Job  from .._abstract_orchestrator import _AbstractOrchestrator  from ._job_dispatcher import _JobDispatcher  from ._task_function_wrapper import _TaskFunctionWrapper      class _StandaloneJobDispatcher(_JobDispatcher):      \"\"\"Manages job dispatching (instances of `Job^` class) in an asynchronous way using a ProcessPoolExecutor.\"\"\"        def __init__(self, orchestrator: Optional[_AbstractOrchestrator]):          super().__init__(orchestrator)          self._executor = ProcessPoolExecutor(Config.job_config.max_nb_of_workers or 1)  # type: ignore          self._nb_available_workers = self._executor._max_workers  # type: ignore        def _dispatch(self, job: Job):          \"\"\"Dispatches the given `Job^` on an available worker for execution.            Parameters:              job (Job^): The job to submit on an executor with an available worker.          \"\"\"          self._nb_available_workers -= 1            config_as_string = _TomlSerializer()._serialize(Config._applied_config)          future = self._executor.submit(_TaskFunctionWrapper(job.id, job.task), config_as_string=config_as_string)            self._set_dispatched_processes(job.id, future)  # type: ignore          future.add_done_callback(self._release_worker)          future.add_done_callback(partial(self._update_job_status_from_future, job))        def _release_worker(self, _):          self._nb_available_workers += 1        def _update_job_status_from_future(self, job: Job, ft):          self._pop_dispatched_process(job.id)  # type: ignore          self._update_job_status(job, ft.result()) "}
{"text": "import threading  from abc import abstractmethod  from typing import Dict, Optional    from taipy.config.config import Config  from taipy.logger._taipy_logger import _TaipyLogger    from ...data._data_manager_factory import _DataManagerFactory  from ...job._job_manager_factory import _JobManagerFactory  from ...job.job import Job  from ...task.task import Task  from .._abstract_orchestrator import _AbstractOrchestrator      class _JobDispatcher(threading.Thread):      \"\"\"Manages job dispatching (instances of `Job^` class) on executors.\"\"\"        _STOP_FLAG = False      _dispatched_processes: Dict = {}      __logger = _TaipyLogger._get_logger()      _nb_available_workers: int = 1        def __init__(self, orchestrator: Optional[_AbstractOrchestrator]):          threading.Thread.__init__(self, name=\"Thread-Taipy-JobDispatcher\")          self.daemon = True          self.orchestrator = orchestrator          self.lock = self.orchestrator.lock  # type: ignore          Config.block_update()        def start(self):          \"\"\"Start the dispatcher\"\"\"          threading.Thread.start(self)        def is_running(self) -> bool:          \"\"\"Return True if the dispatcher is running\"\"\"          return self.is_alive()        def stop(self):          \"\"\"Stop the dispatcher\"\"\"          self._STOP_FLAG = True        def run(self):          _TaipyLogger._get_logger().info(\"Start job dispatcher...\")          while not self._STOP_FLAG:              try:                  if self._can_execute():                      with self.lock:                          job = self.orchestrator.jobs_to_run.get(block=True, timeout=0.1)                      self._execute_job(job)              except Exception:  # In case the last job of the queue has been removed.                  pass        def _can_execute(self) -> bool:          \"\"\"Returns True if the dispatcher have resources to execute a new job.\"\"\"          return self._nb_available_workers > 0        def _execute_job(self, job: Job):          if job.force or self._needs_to_run(job.task):              if job.force:                  self.__logger.info(f\"job {job.id} is forced to be executed.\")              job.running()              self._dispatch(job)          else:              job._unlock_edit_on_outputs()              job.skipped()              self.__logger.info(f\"job {job.id} is skipped.\")        def _execute_jobs_synchronously(self):          while not self.orchestrator.jobs_to_run.empty():              with self.lock:                  try:                      job = self.orchestrator.jobs_to_run.get()                  except Exception:  # In case the last job of the queue has been removed.                      self.__logger.warning(f\"{job.id} is no longer in the list of jobs to run.\")              self._execute_job(job)        @staticmethod      def _needs_to_run(task: Task) -> bool:          \"\"\"          Returns True if the task has no output or if at least one input was modified since the latest run.            Parameters:               task (Task^): The task to run.          Returns:               True if the task needs to run. False otherwise.          \"\"\"          if not task.skippable:              return True          data_manager = _DataManagerFactory._build_manager()          if len(task.output) == 0:              return True          are_outputs_in_cache = all(data_manager._get(dn.id).is_valid for dn in task.output.values())          if not are_outputs_in_cache:              return True          if len(task.input) == 0:              return False          input_last_edit = max(data_manager._get(dn.id).last_edit_date for dn in task.input.values())          output_last_edit = min(data_manager._get(dn.id).last_edit_date for dn in task.output.values())          return input_last_edit > output_last_edit        @abstractmethod      def _dispatch(self, job: Job):          \"\"\"          Dispatches the given `Job^` on an available worker for execution.            Parameters:              job (Job^): The job to submit on an executor with an available worker.          \"\"\"          raise NotImplementedError        @staticmethod      def _update_job_status(job: Job, exceptions):          job.update_status(exceptions)          _JobManagerFactory._build_manager()._set(job)        @classmethod      def _set_dispatched_processes(cls, job_id, process):          cls._dispatched_processes[job_id] = process        @classmethod      def _pop_dispatched_process(cls, job_id, default=None):          return cls._dispatched_processes.pop(job_id, default)  # type: ignore "}
{"text": "from typing import Any, List    from taipy.config._serializer._toml_serializer import _TomlSerializer  from taipy.config.config import Config  from taipy.logger._taipy_logger import _TaipyLogger    from ...data._data_manager_factory import _DataManagerFactory  from ...data.data_node import DataNode  from ...exceptions import DataNodeWritingError  from ...job.job_id import JobId  from ...task.task import Task    logger = _TaipyLogger._get_logger()      class _TaskFunctionWrapper:      \"\"\"Wrapper around task function.\"\"\"        def __init__(self, job_id: JobId, task: Task):          self.job_id = job_id          self.task = task        def __call__(self, **kwargs):          \"\"\"Make this object callable as a function. Actually calls `execute`.\"\"\"          return self.execute(**kwargs)        def execute(self, **kwargs):          \"\"\"Execute the wrapped function. If `config_as_string` is given, then it will be reapplied to the config.\"\"\"          try:              config_as_string = kwargs.pop(\"config_as_string\", None)              if config_as_string:                  logger.info(\"Updating with given config.\")                  Config._applied_config._update(_TomlSerializer()._deserialize(config_as_string))                  Config.block_update()                inputs = list(self.task.input.values())              outputs = list(self.task.output.values())                arguments = self._read_inputs(inputs)              results = self._execute_fct(arguments)              return self._write_data(outputs, results, self.job_id)          except Exception as e:              logger.error(\"Error during task function execution!\", exc_info=1)              return [e]        def _read_inputs(self, inputs: List[DataNode]) -> List[Any]:          data_manager = _DataManagerFactory._build_manager()          return [data_manager._get(dn.id).read_or_raise() for dn in inputs]        def _write_data(self, outputs: List[DataNode], results, job_id: JobId):          data_manager = _DataManagerFactory._build_manager()          try:              if outputs:                  _results = self._extract_results(outputs, results)                  exceptions = []                  for res, dn in zip(_results, outputs):                      try:                          data_node = data_manager._get(dn.id)                          data_node.write(res, job_id=job_id)                          data_manager._set(data_node)                      except Exception as e:                          logger.error(\"Error during write\", exc_info=1)                          exceptions.append(DataNodeWritingError(f\"Error writing in datanode id {dn.id}: {e}\"))                  return exceptions          except Exception as e:              return [e]        def _execute_fct(self, arguments: List[Any]) -> Any:          return self.task.function(*arguments)        def _extract_results(self, outputs: List[DataNode], results: Any) -> List[Any]:          _results: List[Any] = [results] if len(outputs) == 1 else results          if len(_results) != len(outputs):              raise DataNodeWritingError(\"Error: wrong number of result or task output\")          return _results "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from typing import Type    from .._manager._manager_factory import _ManagerFactory  from ..common._utils import _load_fct  from ._task_fs_repository import _TaskFSRepository  from ._task_manager import _TaskManager  from ._task_sql_repository import _TaskSQLRepository      class _TaskManagerFactory(_ManagerFactory):        __REPOSITORY_MAP = {\"default\": _TaskFSRepository, \"sql\": _TaskSQLRepository}        @classmethod      def _build_manager(cls) -> Type[_TaskManager]:  # type: ignore          if cls._using_enterprise():              task_manager = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".task._task_manager\", \"_TaskManager\"              )  # type: ignore              build_repository = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".task._task_manager_factory\", \"_TaskManagerFactory\"              )._build_repository  # type: ignore          else:              task_manager = _TaskManager              build_repository = cls._build_repository          task_manager._repository = build_repository()  # type: ignore          return task_manager  # type: ignore        @classmethod      def _build_repository(cls):          return cls._get_repository_with_repo_map(cls.__REPOSITORY_MAP)() "}
{"text": "  from .._repository._abstract_converter import _AbstractConverter  from .._version._utils import _migrate_entity  from ..common._utils import _load_fct  from ..data._data_manager_factory import _DataManagerFactory  from ..exceptions import NonExistingDataNode  from ..task._task_model import _TaskModel  from ..task.task import Task  from .task import TaskId      class _TaskConverter(_AbstractConverter):      @classmethod      def _entity_to_model(cls, task: Task) -> _TaskModel:          return _TaskModel(              id=task.id,              owner_id=task.owner_id,              parent_ids=list(task._parent_ids),              config_id=task.config_id,              input_ids=cls.__to_ids(task.input.values()),              function_name=task._function.__name__,              function_module=task._function.__module__,              output_ids=cls.__to_ids(task.output.values()),              version=task._version,              skippable=task._skippable,              properties=task._properties.data.copy(),          )        @classmethod      def _model_to_entity(cls, model: _TaskModel) -> Task:          task = Task(              id=TaskId(model.id),              owner_id=model.owner_id,              parent_ids=set(model.parent_ids),              config_id=model.config_id,              function=_load_fct(model.function_module, model.function_name),              input=cls.__to_data_nodes(model.input_ids),              output=cls.__to_data_nodes(model.output_ids),              version=model.version,              skippable=model.skippable,              properties=model.properties,          )          return _migrate_entity(task)        @staticmethod      def __to_ids(data_nodes):          return [i.id for i in data_nodes]        @staticmethod      def __to_data_nodes(data_nodes_ids):          data_nodes = []          data_manager = _DataManagerFactory._build_manager()          for _id in data_nodes_ids:              if data_node := data_manager._get(_id):                  data_nodes.append(data_node)              else:                  raise NonExistingDataNode(_id)          return data_nodes "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._sql_repository import _SQLRepository  from ._task_converter import _TaskConverter  from ._task_model import _TaskModel      class _TaskSQLRepository(_SQLRepository):      def __init__(self):          super().__init__(model_type=_TaskModel, converter=_TaskConverter) "}
{"text": "from dataclasses import dataclass  from typing import Any, Dict, List, Optional    from sqlalchemy import JSON, Boolean, Column, String, Table    from .._repository._base_taipy_model import _BaseModel  from .._repository.db._sql_base_model import mapper_registry      @mapper_registry.mapped  @dataclass  class _TaskModel(_BaseModel):      __table__ = Table(          \"task\",          mapper_registry.metadata,          Column(\"id\", String, primary_key=True),          Column(\"owner_id\", String),          Column(\"parent_ids\", JSON),          Column(\"config_id\", String),          Column(\"input_ids\", JSON),          Column(\"function_name\", String),          Column(\"function_module\", String),          Column(\"output_ids\", JSON),          Column(\"version\", String),          Column(\"skippable\", Boolean),          Column(\"properties\", JSON),      )      id: str      owner_id: Optional[str]      parent_ids: List[str]      config_id: str      input_ids: List[str]      function_name: str      function_module: str      output_ids: List[str]      version: str      skippable: bool      properties: Dict[str, Any]        @staticmethod      def from_dict(data: Dict[str, Any]):          return _TaskModel(              id=data[\"id\"],              owner_id=data.get(\"owner_id\"),              parent_ids=_BaseModel._deserialize_attribute(data.get(\"parent_ids\", [])),              config_id=data[\"config_id\"],              input_ids=_BaseModel._deserialize_attribute(data[\"input_ids\"]),              function_name=data[\"function_name\"],              function_module=data[\"function_module\"],              output_ids=_BaseModel._deserialize_attribute(data[\"output_ids\"]),              version=data[\"version\"],              skippable=data[\"skippable\"],              properties=_BaseModel._deserialize_attribute(data[\"properties\"] if \"properties\" in data.keys() else {}),          )        def to_list(self):          return [              self.id,              self.owner_id,              _BaseModel._serialize_attribute(self.parent_ids),              self.config_id,              _BaseModel._serialize_attribute(self.input_ids),              self.function_name,              self.function_module,              _BaseModel._serialize_attribute(self.output_ids),              self.version,              self.skippable,              _BaseModel._serialize_attribute(self.properties),          ] "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._filesystem_repository import _FileSystemRepository  from ._task_converter import _TaskConverter  from ._task_model import _TaskModel      class _TaskFSRepository(_FileSystemRepository):      def __init__(self):          super().__init__(model_type=_TaskModel, converter=_TaskConverter, dir_name=\"tasks\") "}
{"text": "from typing import NewType    TaskId = NewType(\"TaskId\", str)  TaskId.__doc__ = \"\"\"Type that holds a `Task^` identifier.\"\"\" "}
{"text": "from dataclasses import dataclass  from typing import Any, Dict, List    from sqlalchemy import JSON, Boolean, Column, Enum, String, Table    from .._repository._base_taipy_model import _BaseModel  from .._repository.db._sql_base_model import mapper_registry  from .job_id import JobId  from .status import Status      @mapper_registry.mapped  @dataclass  class _JobModel(_BaseModel):      __table__ = Table(          \"job\",          mapper_registry.metadata,          Column(\"id\", String, primary_key=True),          Column(\"task_id\", String),          Column(\"status\", Enum(Status)),          Column(\"force\", Boolean),          Column(\"submit_id\", String),          Column(\"submit_entity_id\", String),          Column(\"creation_date\", String),          Column(\"subscribers\", JSON),          Column(\"stacktrace\", JSON),          Column(\"version\", String),      )      id: JobId      task_id: str      status: Status      force: bool      submit_id: str      submit_entity_id: str      creation_date: str      subscribers: List[Dict]      stacktrace: List[str]      version: str        @staticmethod      def from_dict(data: Dict[str, Any]):          return _JobModel(              id=data[\"id\"],              task_id=data[\"task_id\"],              status=Status._from_repr(data[\"status\"]),              force=data[\"force\"],              submit_id=data[\"submit_id\"],              submit_entity_id=data[\"submit_entity_id\"],              creation_date=data[\"creation_date\"],              subscribers=_BaseModel._deserialize_attribute(data[\"subscribers\"]),              stacktrace=_BaseModel._deserialize_attribute(data[\"stacktrace\"]),              version=data[\"version\"],          )        def to_list(self):          return [              self.id,              self.task_id,              repr(self.status),              self.force,              self.submit_id,              self.submit_entity_id,              self.creation_date,              _BaseModel._serialize_attribute(self.subscribers),              _BaseModel._serialize_attribute(self.stacktrace),              self.version,          ] "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._filesystem_repository import _FileSystemRepository  from ._job_converter import _JobConverter  from ._job_model import _JobModel      class _JobFSRepository(_FileSystemRepository):      def __init__(self):          super().__init__(model_type=_JobModel, converter=_JobConverter, dir_name=\"jobs\") "}
{"text": "import uuid  from typing import Callable, Iterable, List, Optional, Union    from .._manager._manager import _Manager  from .._repository._abstract_repository import _AbstractRepository  from .._version._version_manager_factory import _VersionManagerFactory  from .._version._version_mixin import _VersionMixin  from ..exceptions.exceptions import JobNotDeletedException  from ..notification import EventEntityType, EventOperation, Notifier, _make_event  from ..task.task import Task  from .job import Job  from .job_id import JobId      class _JobManager(_Manager[Job], _VersionMixin):      _ENTITY_NAME = Job.__name__      _ID_PREFIX = \"JOB_\"      _repository: _AbstractRepository      _EVENT_ENTITY_TYPE = EventEntityType.JOB        @classmethod      def _get_all(cls, version_number: Optional[str] = None) -> List[Job]:          \"\"\"          Returns all entities.          \"\"\"          filters = cls._build_filters_with_version(version_number)          return cls._repository._load_all(filters)        @classmethod      def _create(          cls, task: Task, callbacks: Iterable[Callable], submit_id: str, submit_entity_id: str, force=False      ) -> Job:          version = _VersionManagerFactory._build_manager()._get_latest_version()          job = Job(              id=JobId(f\"{Job._ID_PREFIX}_{task.config_id}_{uuid.uuid4()}\"),              task=task,              submit_id=submit_id,              submit_entity_id=submit_entity_id,              force=force,              version=version,          )          cls._set(job)          Notifier.publish(_make_event(job, EventOperation.CREATION))          job._on_status_change(*callbacks)          return job        @classmethod      def _delete(cls, job: Job, force=False):          if job.is_finished() or force:              super()._delete(job.id)              from .._orchestrator._dispatcher._job_dispatcher import _JobDispatcher                _JobDispatcher._pop_dispatched_process(job.id)          else:              err = JobNotDeletedException(job.id)              cls._logger.warning(err)              raise err        @classmethod      def _cancel(cls, job: Union[str, Job]):          job = cls._get(job) if isinstance(job, str) else job            from .._orchestrator._orchestrator_factory import _OrchestratorFactory            _OrchestratorFactory._build_orchestrator().cancel_job(job)        @classmethod      def _get_latest(cls, task: Task) -> Optional[Job]:          jobs_of_task = list(filter(lambda job: task in job, cls._get_all()))          if len(jobs_of_task) == 0:              return None          if len(jobs_of_task) == 1:              return jobs_of_task[0]          else:              return max(jobs_of_task)        @classmethod      def _is_deletable(cls, job: Union[Job, JobId]) -> bool:          if isinstance(job, str):              job = cls._get(job)          if job.is_finished():              return True          return False "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from typing import NewType    JobId = NewType(\"JobId\", str)  JobId.__doc__ = \"\"\"Type that holds a `Job^` identifier.\"\"\" "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._sql_repository import _SQLRepository  from ._job_converter import _JobConverter  from ._job_model import _JobModel      class _JobSQLRepository(_SQLRepository):      def __init__(self):          super().__init__(model_type=_JobModel, converter=_JobConverter) "}
{"text": "from datetime import datetime  from typing import List    from .._repository._abstract_converter import _AbstractConverter  from ..common._utils import _fcts_to_dict, _load_fct  from ..exceptions import InvalidSubscriber  from ..job._job_model import _JobModel  from ..job.job import Job  from ..task._task_manager_factory import _TaskManagerFactory      class _JobConverter(_AbstractConverter):      @classmethod      def _entity_to_model(cls, job: Job) -> _JobModel:          return _JobModel(              job.id,              job._task.id,              job._status,              job._force,              job.submit_id,              job.submit_entity_id,              job._creation_date.isoformat(),              cls.__serialize_subscribers(job._subscribers),              job._stacktrace,              version=job._version,          )        @classmethod      def _model_to_entity(cls, model: _JobModel) -> Job:          task_manager = _TaskManagerFactory._build_manager()          task_repository = task_manager._repository            job = Job(              id=model.id,              task=task_repository._load(model.task_id),              submit_id=model.submit_id,              submit_entity_id=model.submit_entity_id,              version=model.version,          )            job._status = model.status  # type: ignore          job._force = model.force  # type: ignore          job._creation_date = datetime.fromisoformat(model.creation_date)  # type: ignore          for it in model.subscribers:              try:                  fct_module, fct_name = it.get(\"fct_module\"), it.get(\"fct_name\")                  job._subscribers.append(_load_fct(fct_module, fct_name))  # type: ignore              except AttributeError:                  raise InvalidSubscriber(f\"The subscriber function {it.get('fct_name')} cannot be loaded.\")          job._stacktrace = model.stacktrace            return job        @staticmethod      def __serialize_subscribers(subscribers: List) -> List:          return _fcts_to_dict(subscribers) "}
{"text": "from ..common._repr_enum import _ReprEnum      class Status(_ReprEnum):      \"\"\"Execution status of a `Job^`.        It is implemented as an enumeration.        The possible values are:        - `SUBMITTED`: A `SUBMITTED` job has been submitted for execution but not processed yet by          the orchestrator.        - `PENDING`: A `PENDING` job has been enqueued by the orchestrator. It is waiting for an executor          to be available for its execution.        - `BLOCKED`: A `BLOCKED` job has been blocked because its input data nodes are not ready yet.          It is waiting for the completion of another `Job^`        - `RUNNING`: A `RUNNING` job is currently executed by a dedicated executor.        - `CANCELED`: A `CANCELED` job has been submitted but its execution has been canceled.        - `FAILED`: A `FAILED` job raised an exception during its execution.        - `COMPLETED`: A `COMPLETED` job has successfully been executed.        - `SKIPPED`: A `SKIPPED` job has not been executed because its outputs were already computed.        - `ABANDONED`: An `ABANDONED` job has not been executed because it depends on a job that could not complete (          cancelled, failed, or abandoned).      \"\"\"        SUBMITTED = 1      BLOCKED = 2      PENDING = 3      RUNNING = 4      CANCELED = 5      FAILED = 6      COMPLETED = 7      SKIPPED = 8      ABANDONED = 9 "}
{"text": "from typing import Type    from .._manager._manager_factory import _ManagerFactory  from ..common._utils import _load_fct  from ._job_fs_repository import _JobFSRepository  from ._job_manager import _JobManager  from ._job_sql_repository import _JobSQLRepository      class _JobManagerFactory(_ManagerFactory):        __REPOSITORY_MAP = {\"default\": _JobFSRepository, \"sql\": _JobSQLRepository}        @classmethod      def _build_manager(cls) -> Type[_JobManager]:  # type: ignore          if cls._using_enterprise():              job_manager = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".job._job_manager\", \"_JobManager\"              )  # type: ignore              build_repository = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".job._job_manager_factory\", \"_JobManagerFactory\"              )._build_repository  # type: ignore          else:              job_manager = _JobManager              build_repository = cls._build_repository          job_manager._repository = build_repository()  # type: ignore          return job_manager  # type: ignore        @classmethod      def _build_repository(cls):          return cls._get_repository_with_repo_map(cls.__REPOSITORY_MAP)() "}
{"text": "from typing import NewType    SequenceId = NewType(\"SequenceId\", str)  SequenceId.__doc__ = \"\"\"Type that holds a `Sequence^` identifier.\"\"\" "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from typing import Dict    from .._repository._abstract_converter import _AbstractConverter  from ..common import _utils  from ..task.task import Task  from .sequence import Sequence      class _SequenceConverter(_AbstractConverter):      _SEQUENCE_MODEL_ID_KEY = \"id\"      _SEQUENCE_MODEL_OWNER_ID_KEY = \"owner_id\"      _SEQUENCE_MODEL_PARENT_IDS_KEY = \"parent_ids\"      _SEQUENCE_MODEL_PROPERTIES_KEY = \"properties\"      _SEQUENCE_MODEL_TASKS_KEY = \"tasks\"      _SEQUENCE_MODEL_SUBSCRIBERS_KEY = \"subscribers\"      _SEQUENCE_MODEL_VERSION_KEY = \"version\"        @classmethod      def _entity_to_model(cls, sequence: Sequence) -> Dict:          return {              \"id\": sequence.id,              \"owner_id\": sequence.owner_id,              \"parent_ids\": list(sequence._parent_ids),              \"properties\": sequence._properties.data,              \"tasks\": cls.__to_task_ids(sequence._tasks),              \"subscribers\": _utils._fcts_to_dict(sequence._subscribers),              \"version\": sequence._version,          }        @staticmethod      def __to_task_ids(tasks):          return [t.id if isinstance(t, Task) else t for t in tasks] "}
{"text": "from typing import Type    from .._manager._manager_factory import _ManagerFactory  from ..common._utils import _load_fct  from ._sequence_manager import _SequenceManager      class _SequenceManagerFactory(_ManagerFactory):      @classmethod      def _build_manager(cls) -> Type[_SequenceManager]:  # type: ignore          if cls._using_enterprise():              sequence_manager = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".sequence._sequence_manager\", \"_SequenceManager\"              )  # type: ignore          else:              sequence_manager = _SequenceManager          return sequence_manager  # type: ignore "}
{"text": "from ..exceptions.exceptions import InvalidExposedType      class _AbstractTabularDataNode(object):      \"\"\"Abstract base class for tabular data node implementations (CSVDataNode, ParquetDataNode, ExcelDataNode,      SQLTableDataNode and SQLDataNode) that are tabular representable.\"\"\"        @staticmethod      def _check_exposed_type(exposed_type, valid_string_exposed_types):          if isinstance(exposed_type, str) and exposed_type not in valid_string_exposed_types:              raise InvalidExposedType(                  f\"Invalid string exposed type {exposed_type}. Supported values are \"                  f\"{', '.join(valid_string_exposed_types)}\"              ) "}
{"text": "from enum import Enum      class Operator(Enum):      \"\"\"Enumeration of operators for Data Node filtering.        The possible values are:        - `EQUAL`      - `NOT_EQUAL`      - `LESS_THAN`      - `LESS_OR_EQUAL`      - `GREATER_THAN`      - `GREATER_OR_EQUAL`      \"\"\"        EQUAL = 1      NOT_EQUAL = 2      LESS_THAN = 3      LESS_OR_EQUAL = 4      GREATER_THAN = 5      GREATER_OR_EQUAL = 6      class JoinOperator(Enum):      \"\"\"      Enumeration of join operators for Data Node filtering. The possible values are `AND` and `OR`.      \"\"\"        AND = 1      OR = 2 "}
{"text": "from .csv import CSVDataNode  from .data_node import DataNode  from .excel import ExcelDataNode  from .generic import GenericDataNode  from .in_memory import InMemoryDataNode  from .json import JSONDataNode  from .mongo import MongoCollectionDataNode  from .operator import JoinOperator, Operator  from .parquet import ParquetDataNode  from .pickle import PickleDataNode  from .sql import SQLDataNode  from .sql_table import SQLTableDataNode "}
{"text": "import pathlib      class _AbstractFileDataNode(object):      \"\"\"Abstract base class for data node implementations (CSVDataNode, ParquetDataNode, ExcelDataNode,      PickleDataNode and JSONDataNode) that are file based.\"\"\"        __EXTENSION_MAP = {\"csv\": \"csv\", \"excel\": \"xlsx\", \"parquet\": \"parquet\", \"pickle\": \"p\", \"json\": \"json\"}        def _build_path(self, storage_type):          from taipy.config.config import Config            folder = f\"{storage_type}s\"          dir_path = pathlib.Path(Config.core.storage_folder) / folder          if not dir_path.exists():              dir_path.mkdir(parents=True, exist_ok=True)          return dir_path / f\"{self.id}.{self.__EXTENSION_MAP.get(storage_type)}\" "}
{"text": "from typing import Type    from .._manager._manager_factory import _ManagerFactory  from ..common._utils import _load_fct  from ._data_fs_repository import _DataFSRepository  from ._data_manager import _DataManager  from ._data_sql_repository import _DataSQLRepository      class _DataManagerFactory(_ManagerFactory):        __REPOSITORY_MAP = {\"default\": _DataFSRepository, \"sql\": _DataSQLRepository}        @classmethod      def _build_manager(cls) -> Type[_DataManager]:  # type: ignore          if cls._using_enterprise():              data_manager = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".data._data_manager\", \"_DataManager\"              )  # type: ignore              build_repository = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".data._data_manager_factory\", \"_DataManagerFactory\"              )._build_repository  # type: ignore          else:              data_manager = _DataManager              build_repository = cls._build_repository          data_manager._repository = build_repository()  # type: ignore          return data_manager  # type: ignore        @classmethod      def _build_repository(cls):          return cls._get_repository_with_repo_map(cls.__REPOSITORY_MAP)() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._sql_repository import _SQLRepository  from ._data_converter import _DataNodeConverter  from ._data_model import _DataNodeModel      class _DataSQLRepository(_SQLRepository):      def __init__(self):          super().__init__(model_type=_DataNodeModel, converter=_DataNodeConverter) "}
{"text": "from dataclasses import dataclass  from typing import Any, Dict, List, Optional    from sqlalchemy import JSON, Boolean, Column, Enum, Float, String, Table, UniqueConstraint    from taipy.config.common.scope import Scope    from .._repository._base_taipy_model import _BaseModel  from .._repository.db._sql_base_model import mapper_registry  from .data_node_id import Edit      @mapper_registry.mapped  @dataclass  class _DataNodeModel(_BaseModel):      __table__ = Table(          \"data_node\",          mapper_registry.metadata,          Column(\"id\", String, primary_key=True),          Column(\"config_id\", String),          Column(\"scope\", Enum(Scope)),          Column(\"storage_type\", String),          Column(\"owner_id\", String),          Column(\"parent_ids\", JSON),          Column(\"last_edit_date\", String),          Column(\"edits\", JSON),          Column(\"version\", String),          Column(\"validity_days\", Float),          Column(\"validity_seconds\", Float),          Column(\"edit_in_progress\", Boolean),          Column(\"editor_id\", String),          Column(\"editor_expiration_date\", String),          Column(\"data_node_properties\", JSON),      )      __table_args__ = (UniqueConstraint(\"config_id\", \"owner_id\", name=\"_config_owner_uc\"),)        id: str      config_id: str      scope: Scope      storage_type: str      owner_id: Optional[str]      parent_ids: List[str]      last_edit_date: Optional[str]      edits: List[Edit]      version: str      validity_days: Optional[float]      validity_seconds: Optional[float]      edit_in_progress: bool      editor_id: Optional[str]      editor_expiration_date: Optional[str]      data_node_properties: Dict[str, Any]        @staticmethod      def from_dict(data: Dict[str, Any]):          return _DataNodeModel(              id=data[\"id\"],              config_id=data[\"config_id\"],              scope=Scope._from_repr(data[\"scope\"]),              storage_type=data[\"storage_type\"],              owner_id=data.get(\"owner_id\"),              parent_ids=data.get(\"parent_ids\", []),              last_edit_date=data.get(\"last_edit_date\"),              edits=_BaseModel._deserialize_attribute(data[\"edits\"]),              version=data[\"version\"],              validity_days=data[\"validity_days\"],              validity_seconds=data[\"validity_seconds\"],              edit_in_progress=bool(data.get(\"edit_in_progress\", False)),              editor_id=data.get(\"editor_id\", None),              editor_expiration_date=data.get(\"editor_expiration_date\"),              data_node_properties=_BaseModel._deserialize_attribute(data[\"data_node_properties\"]),          )        def to_list(self):          return [              self.id,              self.config_id,              repr(self.scope),              self.storage_type,              self.owner_id,              _BaseModel._serialize_attribute(self.parent_ids),              self.last_edit_date,              _BaseModel._serialize_attribute(self.edits),              self.version,              self.validity_days,              self.validity_seconds,              self.edit_in_progress,              self.editor_id,              self.editor_expiration_date,              _BaseModel._serialize_attribute(self.data_node_properties),          ] "}
{"text": "from datetime import datetime, timedelta  from typing import Any, Dict, List, Optional, Set    from taipy.config.common.scope import Scope    from .._version._version_manager_factory import _VersionManagerFactory  from .data_node import DataNode  from .data_node_id import DataNodeId, Edit    in_memory_storage: Dict[str, Any] = {}      class InMemoryDataNode(DataNode):      \"\"\"Data Node stored in memory.        Warning:          This Data Node implementation is not compatible with a parallel execution of taipy tasks,          but only with a task executor in development mode. The purpose of `InMemoryDataNode` is to be used          for development or debugging.        Attributes:          config_id (str): Identifier of the data node configuration. It must be a valid Python              identifier.          scope (Scope^): The scope of this data node.          id (str): The unique identifier of this data node.          owner_id (str): The identifier of the owner (sequence_id, scenario_id, cycle_id) or              `None`.          parent_ids (Optional[Set[str]]): The identifiers of the parent tasks or `None`.          last_edit_date (datetime): The date and time of the last modification.          edits (List[Edit^]): The ordered list of edits for that job.          version (str): The string indicates the application version of the data node to instantiate. If not provided,              the current version is used.          validity_period (Optional[timedelta]): The duration implemented as a timedelta since the last edit date for              which the data node can be considered up-to-date. Once the validity period has passed, the data node is              considered stale and relevant tasks will run even if they are skippable (see the              [Task management page](../core/entities/task-mgt.md) for more details).              If _validity_period_ is set to `None`, the data node is always up-to-date.          edit_in_progress (bool): True if a task computing the data node has been submitted              and not completed yet. False otherwise.          editor_id (Optional[str]): The identifier of the user who is currently editing the data node.          editor_expiration_date (Optional[datetime]): The expiration date of the editor lock.          properties (dict[str, Any]): A dictionary of additional properties. When creating an              _In Memory_ data node, if the _properties_ dictionary contains a _\"default_data\"_              entry, the data node is automatically written with the corresponding _\"default_data\"_              value.      \"\"\"        __STORAGE_TYPE = \"in_memory\"      __DEFAULT_DATA_VALUE = \"default_data\"      _REQUIRED_PROPERTIES: List[str] = []        def __init__(          self,          config_id: str,          scope: Scope,          id: Optional[DataNodeId] = None,          owner_id: Optional[str] = None,          parent_ids: Optional[Set[str]] = None,          last_edit_date: Optional[datetime] = None,          edits: List[Edit] = None,          version: str = None,          validity_period: Optional[timedelta] = None,          edit_in_progress: bool = False,          editor_id: Optional[str] = None,          editor_expiration_date: Optional[datetime] = None,          properties=None,      ):          if properties is None:              properties = {}          default_value = properties.pop(self.__DEFAULT_DATA_VALUE, None)          super().__init__(              config_id,              scope,              id,              owner_id,              parent_ids,              last_edit_date,              edits,              version or _VersionManagerFactory._build_manager()._get_latest_version(),              validity_period,              edit_in_progress,              editor_id,              editor_expiration_date,              **properties          )          if default_value is not None and self.id not in in_memory_storage:              self._write(default_value)              self._last_edit_date = datetime.now()              self._edits.append(                  Edit(                      {                          \"timestamp\": self._last_edit_date,                          \"writer_identifier\": \"TAIPY\",                          \"comments\": \"Default data written.\",                      }                  )              )            self._TAIPY_PROPERTIES.update({self.__DEFAULT_DATA_VALUE})        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        def _read(self):          return in_memory_storage.get(self.id)        def _write(self, data):          in_memory_storage[self.id] = data "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._filesystem_repository import _FileSystemRepository  from ._data_converter import _DataNodeConverter  from ._data_model import _DataNodeModel      class _DataFSRepository(_FileSystemRepository):      def __init__(self):          super().__init__(model_type=_DataNodeModel, converter=_DataNodeConverter, dir_name=\"data_nodes\") "}
{"text": "from typing import Any, Dict, NewType    DataNodeId = NewType(\"DataNodeId\", str)  DataNodeId.__doc__ = \"\"\"Type that holds a `DataNode^` identifier.\"\"\"  Edit = NewType(\"Edit\", Dict[str, Any])  Edit.__doc__ = \"\"\"Type that holds a `DataNode^` edit information.\"\"\" "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._filesystem_repository import _FileSystemRepository  from ._submission_converter import _SubmissionConverter  from ._submission_model import _SubmissionModel      class _SubmissionFSRepository(_FileSystemRepository):      def __init__(self):          super().__init__(model_type=_SubmissionModel, converter=_SubmissionConverter, dir_name=\"submission\") "}
{"text": "from typing import NewType    SubmissionId = NewType(\"SubmissionId\", str)  SubmissionId.__doc__ = \"\"\"Type that holds a `Submission^` identifier.\"\"\" "}
{"text": "from ..common._repr_enum import _ReprEnum      class SubmissionStatus(_ReprEnum):      \"\"\"Execution status of a `Submission^`.        It is implemented as an enumeration.        The possible values are:        - `SUBMITTED`: A `SUBMITTED` submission has been submitted for execution but not processed yet by          the orchestrator.        - `UNDEFINED`: AN `UNDEFINED` submission's jobs have been submitted for execution but got some undefined          status changes.        - `PENDING`: A `PENDING` submission has been enqueued by the orchestrator. It is waiting for an executor          to be available for its execution.        - `BLOCKED`: A `BLOCKED` submission has been blocked because it has been finished with a job being blocked.        - `RUNNING`: A `RUNNING` submission has its jobs currently being executed.        - `CANCELED`: A `CANCELED` submission has been submitted but its execution has been canceled.        - `FAILED`: A `FAILED` submission has a job failed during its execution.        - `COMPLETED`: A `COMPLETED` submission has successfully been executed.      \"\"\"        SUBMITTED = 0      UNDEFINED = 1      BLOCKED = 2      PENDING = 3      RUNNING = 4      CANCELED = 5      FAILED = 6      COMPLETED = 7 "}
{"text": "from dataclasses import dataclass  from typing import Any, Dict, List, Union    from sqlalchemy import JSON, Column, Enum, String, Table    from .._repository._base_taipy_model import _BaseModel  from .._repository.db._sql_base_model import mapper_registry  from ..job.job_id import JobId  from .submission_status import SubmissionStatus      @mapper_registry.mapped  @dataclass  class _SubmissionModel(_BaseModel):      __table__ = Table(          \"submission\",          mapper_registry.metadata,          Column(\"id\", String, primary_key=True),          Column(\"entity_id\", String),          Column(\"entity_type\", String),          Column(\"job_ids\", JSON),          Column(\"creation_date\", String),          Column(\"submission_status\", Enum(SubmissionStatus)),          Column(\"version\", String),      )      id: str      entity_id: str      entity_type: str      job_ids: Union[List[JobId], List]      creation_date: str      submission_status: SubmissionStatus      version: str        @staticmethod      def from_dict(data: Dict[str, Any]):          return _SubmissionModel(              id=data[\"id\"],              entity_id=data[\"entity_id\"],              entity_type=data[\"entity_type\"],              job_ids=_BaseModel._deserialize_attribute(data[\"job_ids\"]),              creation_date=data[\"creation_date\"],              submission_status=SubmissionStatus._from_repr(data[\"submission_status\"]),              version=data[\"version\"],          )        def to_list(self):          return [              self.id,              self.entity_id,              self.entity_type,              _BaseModel._serialize_attribute(self.job_ids),              self.creation_date,              repr(self.submission_status),              self.version,          ] "}
{"text": "from datetime import datetime    from .._repository._abstract_converter import _AbstractConverter  from ..job.job import Job, JobId  from ..submission._submission_model import _SubmissionModel  from ..submission.submission import Submission  from .submission import SubmissionId      class _SubmissionConverter(_AbstractConverter):      @classmethod      def _entity_to_model(cls, submission: Submission) -> _SubmissionModel:          return _SubmissionModel(              id=submission.id,              entity_id=submission._entity_id,              entity_type=submission.entity_type,              job_ids=[job.id if isinstance(job, Job) else JobId(str(job)) for job in list(submission._jobs)],              creation_date=submission._creation_date.isoformat(),              submission_status=submission._submission_status,              version=submission._version,          )        @classmethod      def _model_to_entity(cls, model: _SubmissionModel) -> Submission:          submission = Submission(              entity_id=model.entity_id,              entity_type=model.entity_type,              id=SubmissionId(model.id),              jobs=model.job_ids,              creation_date=datetime.fromisoformat(model.creation_date),              submission_status=model.submission_status,              version=model.version,          )          return submission "}
{"text": "from typing import List, Optional, Union    from .._manager._manager import _Manager  from .._repository._abstract_repository import _AbstractRepository  from .._version._version_mixin import _VersionMixin  from ..notification import EventEntityType, EventOperation, Notifier, _make_event  from ..scenario.scenario import Scenario  from ..sequence.sequence import Sequence  from ..submission.submission import Submission  from ..task.task import Task      class _SubmissionManager(_Manager[Submission], _VersionMixin):      _ENTITY_NAME = Submission.__name__      _repository: _AbstractRepository      _EVENT_ENTITY_TYPE = EventEntityType.SUBMISSION        @classmethod      def _get_all(cls, version_number: Optional[str] = None) -> List[Submission]:          \"\"\"          Returns all entities.          \"\"\"          filters = cls._build_filters_with_version(version_number)          return cls._repository._load_all(filters)        @classmethod      def _create(cls, entity_id: str, entity_type: str) -> Submission:          submission = Submission(entity_id=entity_id, entity_type=entity_type)          cls._set(submission)            Notifier.publish(_make_event(submission, EventOperation.CREATION))            return submission        @classmethod      def _get_latest(cls, entity: Union[Scenario, Sequence, Task]) -> Optional[Submission]:          entity_id = entity.id if not isinstance(entity, str) else entity          submissions_of_task = list(filter(lambda submission: submission.entity_id == entity_id, cls._get_all()))          if len(submissions_of_task) == 0:              return None          if len(submissions_of_task) == 1:              return submissions_of_task[0]          else:              return max(submissions_of_task) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from typing import Type    from .._manager._manager_factory import _ManagerFactory  from ..common._utils import _load_fct  from ._submission_fs_repository import _SubmissionFSRepository  from ._submission_manager import _SubmissionManager  from ._submission_sql_repository import _SubmissionSQLRepository      class _SubmissionManagerFactory(_ManagerFactory):        __REPOSITORY_MAP = {\"default\": _SubmissionFSRepository, \"sql\": _SubmissionSQLRepository}        @classmethod      def _build_manager(cls) -> Type[_SubmissionManager]:  # type: ignore          if cls._using_enterprise():              submission_manager = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".submission._submission_manager\", \"_SubmissionManager\"              )  # type: ignore              build_repository = _load_fct(                  cls._TAIPY_ENTERPRISE_CORE_MODULE + \".submission._submission_manager_factory\",                  \"_SubmissionManagerFactory\",              )._build_repository  # type: ignore          else:              submission_manager = _SubmissionManager              build_repository = cls._build_repository          submission_manager._repository = build_repository()  # type: ignore          return submission_manager  # type: ignore        @classmethod      def _build_repository(cls):          return cls._get_repository_with_repo_map(cls.__REPOSITORY_MAP)() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from .._repository._sql_repository import _SQLRepository  from ._submission_converter import _SubmissionConverter  from ._submission_model import _SubmissionModel      class _SubmissionSQLRepository(_SQLRepository):      def __init__(self):          super().__init__(model_type=_SubmissionModel, converter=_SubmissionConverter) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import logging.config  import os  import sys      class _TaipyLogger:      _ENVIRONMENT_VARIABLE_NAME_WITH_LOGGER_CONFIG_PATH = \"TAIPY_LOGGER_CONFIG_PATH\"        __logger = None        @classmethod      def _get_logger(cls):          cls._ENVIRONMENT_VARIABLE_NAME_WITH_LOGGER_CONFIG_PATH = \"TAIPY_LOGGER_CONFIG_PATH\"            if cls.__logger:              return cls.__logger            if config_filename := os.environ.get(cls._ENVIRONMENT_VARIABLE_NAME_WITH_LOGGER_CONFIG_PATH):              logging.config.fileConfig(config_filename)              cls.__logger = logging.getLogger(\"Taipy\")          else:              cls.__logger = logging.getLogger(\"Taipy\")              cls.__logger.setLevel(logging.INFO)              ch = logging.StreamHandler(sys.stdout)              ch.setLevel(logging.INFO)              formatter = logging.Formatter(\"[%(asctime)s][%(name)s][%(levelname)s] %(message)s\", \"%Y-%m-%d %H:%M:%S\")              ch.setFormatter(formatter)              cls.__logger.addHandler(ch)          return cls.__logger "}
{"text": "import json  import os      def _get_version():      with open(f\"{os.path.dirname(os.path.abspath(__file__))}{os.sep}version.json\") as version_file:          version = json.load(version_file)          version_string = f'{version.get(\"major\", 0)}.{version.get(\"minor\", 0)}.{version.get(\"patch\", 0)}'          if vext := version.get(\"ext\"):              version_string = f\"{version_string}.{vext}\"      return version_string "}
{"text": "from .common.frequency import Frequency  from .common.scope import Scope  from .config import Config "}
{"text": "\"\"\"# Taipy Config    The Taipy Config package is a Python library designed to configure a Taipy application.    The main entrypoint is the `Config^` singleton class. It exposes some methods to configure the  Taipy application and some attributes to retrieve the configuration values.    \"\"\"    from typing import List    from ._init import Config  from .checker.issue import Issue  from .checker.issue_collector import IssueCollector  from .global_app.global_app_config import GlobalAppConfig  from .section import Section  from .unique_section import UniqueSection  from .version import _get_version    __version__ = _get_version()      def _config_doc(func):      def func_with_doc(section, attribute_name, default, configuration_methods, add_to_unconflicted_sections=False):          import os            if os.environ.get(\"GENERATING_TAIPY_DOC\", None) and os.environ[\"GENERATING_TAIPY_DOC\"] == \"true\":              with open(\"config_doc.txt\", \"a\") as f:                  from inspect import signature                    for exposed_configuration_method, configuration_method in configuration_methods:                      annotation = \"    @staticmethod\\n\"                      sign = \"    def \" + exposed_configuration_method + str(signature(configuration_method)) + \":\\n\"                      doc = '        \"\"\"' + configuration_method.__doc__ + '\"\"\"\\n'                      content = \"        pass\\n\\n\"                      f.write(annotation + sign + doc + content)          return func(section, attribute_name, default, configuration_methods, add_to_unconflicted_sections)        return func_with_doc      @_config_doc  def _inject_section(      section_clazz,      attribute_name: str,      default: Section,      configuration_methods: List[tuple],      add_to_unconflicted_sections: bool = False,  ):      Config._register_default(default)        if issubclass(section_clazz, UniqueSection):          setattr(Config, attribute_name, Config.unique_sections[section_clazz.name])      elif issubclass(section_clazz, Section):          setattr(Config, attribute_name, Config.sections[section_clazz.name])      else:          raise TypeError        if add_to_unconflicted_sections:          Config._comparator._add_unconflicted_section(section_clazz.name)  # type: ignore        for exposed_configuration_method, configuration_method in configuration_methods:          setattr(Config, exposed_configuration_method, configuration_method) "}
{"text": "from abc import abstractmethod  from typing import Any, Dict, Optional    from .common._config_blocker import _ConfigBlocker  from .common._template_handler import _TemplateHandler as _tpl  from .common._validate_id import _validate_id      class Section:      \"\"\"A Section as a consistent part of the Config.        A section is defined by the section name (representing the type of objects that are configured) and a section id.      \"\"\"        _DEFAULT_KEY = \"default\"      _ID_KEY = \"id\"        def __init__(self, id, **properties):          self.id = _validate_id(id)          self._properties = properties or dict()        @abstractmethod      def __copy__(self):          raise NotImplementedError        @property      @abstractmethod      def name(self):          raise NotImplementedError        @abstractmethod      def _clean(self):          raise NotImplementedError        @abstractmethod      def _to_dict(self):          raise NotImplementedError        @classmethod      @abstractmethod      def _from_dict(cls, config_as_dict: Dict[str, Any], id, config):          raise NotImplementedError        @abstractmethod      def _update(self, config_as_dict, default_section=None):          raise NotImplementedError        def __getattr__(self, item: str) -> Optional[Any]:          return self._replace_templates(self._properties.get(item, None))        @property      def properties(self):          return {k: _tpl._replace_templates(v) for k, v in self._properties.items()}        @properties.setter  # type: ignore      @_ConfigBlocker._check()      def properties(self, val):          self._properties = val        def _replace_templates(self, value):          return _tpl._replace_templates(value) "}
{"text": "#!/usr/bin/env python    \"\"\"The setup script.\"\"\"  import json  import os    from setuptools import find_namespace_packages, find_packages, setup    with open(\"README.md\") as readme_file:      readme = readme_file.read()    with open(f\"src{os.sep}taipy{os.sep}config{os.sep}version.json\") as version_file:      version = json.load(version_file)      version_string = f'{version.get(\"major\", 0)}.{version.get(\"minor\", 0)}.{version.get(\"patch\", 0)}'      if vext := version.get(\"ext\"):          version_string = f\"{version_string}.{vext}\"    requirements = [\"toml>=0.10,<0.11\", \"deepdiff>=6.2,<6.3\"]    test_requirements = [\"pytest>=3.8\"]    setup(      author=\"Avaiga\",      author_email=\"dev@taipy.io\",      python_requires=\">=3.8\",      classifiers=[          \"Intended Audience :: Developers\",          \"License :: OSI Approved :: Apache Software License\",          \"Natural Language :: English\",          \"Programming Language :: Python :: 3\",          \"Programming Language :: Python :: 3.8\",          \"Programming Language :: Python :: 3.9\",          \"Programming Language :: Python :: 3.10\",      ],      description=\"A Taipy package dedicated to easily configure a Taipy application.\",      install_requires=requirements,      long_description=readme,      long_description_content_type=\"text/markdown\",      include_package_data=True,      license=\"Apache License 2.0\",      keywords=\"taipy-config\",      name=\"taipy-config\",      package_dir={\"\": \"src\"},      packages=find_namespace_packages(where=\"src\")      + find_packages(include=[\"taipy\", \"taipy.config\", \"taipy.config.*\", \"taipy.logger\", \"taipy.logger.*\"]),      test_suite=\"tests\",      tests_require=test_requirements,      url=\"https://github.com/avaiga/taipy-config\",      version=version_string,      zip_safe=False,  ) "}
{"text": "from abc import ABC    from .common._validate_id import _validate_id  from .section import Section      class UniqueSection(Section, ABC):      \"\"\"A UniqueSection is a configuration `Section^` that can have only one instance.        A UniqueSection is only defined by the section name.      \"\"\"        def __init__(self, **properties):          super().__init__(self.name, **properties) "}
{"text": "from copy import copy  from typing import Dict    from .global_app.global_app_config import GlobalAppConfig  from .section import Section  from .unique_section import UniqueSection      class _Config:      DEFAULT_KEY = \"default\"        def __init__(self):          self._sections: Dict[str, Dict[str, Section]] = {}          self._unique_sections: Dict[str, UniqueSection] = {}          self._global_config: GlobalAppConfig = GlobalAppConfig()        def _clean(self):          self._global_config._clean()          for unique_section in self._unique_sections.values():              unique_section._clean()          for sections in self._sections.values():              for section in sections.values():                  section._clean()        @classmethod      def _default_config(cls):          config = _Config()          config._global_config = GlobalAppConfig.default_config()          return config        def _update(self, other_config):          self._global_config._update(other_config._global_config._to_dict())          if other_config._unique_sections:              for section_name, other_section in other_config._unique_sections.items():                  if section := self._unique_sections.get(section_name, None):                      section._update(other_section._to_dict())                  else:                      self._unique_sections[section_name] = copy(other_config._unique_sections[section_name])          if other_config._sections:              for section_name, other_non_unique_sections in other_config._sections.items():                  if non_unique_sections := self._sections.get(section_name, None):                      self.__update_sections(non_unique_sections, other_non_unique_sections)                  else:                      self._sections[section_name] = {}                      self.__add_sections(self._sections[section_name], other_non_unique_sections)        def __add_sections(self, entity_config, other_entity_configs):          for cfg_id, sub_config in other_entity_configs.items():              entity_config[cfg_id] = copy(sub_config)              self.__point_nested_section_to_self(sub_config)        def __update_sections(self, entity_config, other_entity_configs):          if self.DEFAULT_KEY in other_entity_configs:              if self.DEFAULT_KEY in entity_config:                  entity_config[self.DEFAULT_KEY]._update(other_entity_configs[self.DEFAULT_KEY]._to_dict())              else:                  entity_config[self.DEFAULT_KEY] = other_entity_configs[self.DEFAULT_KEY]          for cfg_id, sub_config in other_entity_configs.items():              if cfg_id != self.DEFAULT_KEY:                  if cfg_id in entity_config:                      entity_config[cfg_id]._update(sub_config._to_dict(), entity_config.get(self.DEFAULT_KEY))                  else:                      entity_config[cfg_id] = copy(sub_config)                      entity_config[cfg_id]._update(sub_config._to_dict(), entity_config.get(self.DEFAULT_KEY))              self.__point_nested_section_to_self(sub_config)        def __point_nested_section_to_self(self, section):          \"\"\"Loop through attributes of a Section to find if any attribute has a list of Section as value.          If there is, update each nested Section by the corresponding instance in self.            Args:              section (Section): The Section to search for nested sections.          \"\"\"          for _, attr_value in vars(section).items():              # ! This will fail if an attribute is a dictionary, or nested list of Sections.              if not isinstance(attr_value, list):                  continue                for index, item in enumerate(attr_value):                  if not isinstance(item, Section):                      continue                    if sub_item := self._sections.get(item.name, {}).get(item.id, None):                      attr_value[index] = sub_item "}
{"text": "import ast  import re  from pathlib import Path  from typing import List      def _get_function_delimiters(initial_line, lines):      begin = end = initial_line      while True:          if lines[begin - 1] == \"\\n\":              break          begin -= 1        if lines[end].endswith(\"(\\n\"):          while \":\\n\" not in lines[end]:              end += 1        if '\"\"\"' in lines[end + 1]:          while True:              if '\"\"\"\\n' in lines[end]:                  break              end += 1      return begin, end + 1      def _get_file_lines(filename: str) -> List[str]:      # Get file lines for later      with open(filename) as f:          return f.readlines()      def _get_file_ast(filename: str):      # Get raw text and build ast      _config = Path(filename)      _tree = _config.read_text()      return ast.parse(_tree)      def _build_base_config_pyi(filename, base_pyi):      lines = _get_file_lines(filename)      tree = _get_file_ast(filename)        class_lineno = [f.lineno for f in ast.walk(tree) if isinstance(f, ast.ClassDef) and f.name == \"Config\"]      begin_class, end_class = _get_function_delimiters(class_lineno[0] - 1, lines)        base_pyi += \"\".join(lines[begin_class:end_class])      functions = [f.lineno for f in ast.walk(tree) if isinstance(f, ast.FunctionDef) and not f.name.startswith(\"__\")]        for ln in functions:          begin_line, end_line = _get_function_delimiters(ln - 1, lines)          base_pyi += \"\".join(lines[begin_line:end_line])            base_pyi = __add_docstring(base_pyi, lines, end_line)          base_pyi += \"\\n\"        return base_pyi      def __add_docstring(base_pyi, lines, end_line):      if '\"\"\"' not in lines[end_line - 1]:          base_pyi += '\\t\\t\"\"\"\"\"\"\\n'.replace(\"\\t\", \"    \")      return base_pyi      def _build_entity_config_pyi(base_pyi, filename, entity_map):      lines = _get_file_lines(filename)      tree = _get_file_ast(filename)      functions = {}        for f in ast.walk(tree):          if isinstance(f, ast.FunctionDef):              if \"_configure\" in f.name and not f.name.startswith(\"__\"):                  functions[f.name] = f.lineno              elif \"_set_default\" in f.name and not f.name.startswith(\"__\"):                  functions[f.name] = f.lineno              elif \"_add\" in f.name and not f.name.startswith(\"__\"):                  functions[f.name] = f.lineno        for k, v in functions.items():          begin_line, end_line = _get_function_delimiters(v - 1, lines)          try:              func = \"\".join(lines[begin_line:end_line])              func = func if not k.startswith(\"_\") else func.replace(k, entity_map.get(k))              func = __add_docstring(func, lines, end_line) + \"\\n\"              base_pyi += func          except Exception:              print(f\"key={k}\")              raise        return base_pyi      def _generate_entity_and_property_maps(filename):      entities_map = {}      property_map = {}      entity_tree = _get_file_ast(filename)      functions = [          f for f in ast.walk(entity_tree) if isinstance(f, ast.Call) and getattr(f.func, \"id\", \"\") == \"_inject_section\"      ]        for f in functions:          entity = ast.unparse(f.args[0])          entities_map[entity] = {}          property_map[eval(ast.unparse(f.args[1]))] = entity          # Remove class name from function map          text = ast.unparse(f.args[-1]).replace(f\"{entity}.\", \"\")          matches = re.findall(r\"\\((.*?)\\)\", text)            for m in matches:              v, k = m.replace(\"'\", \"\").split(\",\")              entities_map[entity][k.strip()] = v      return entities_map, property_map      def _generate_acessors(base_pyi, property_map):      for property, cls in property_map.items():          return_template = f\"Dict[str, {cls}]\" if property != \"job_config\" else f\"{cls}\"          template = (\"\\t@_Classproperty\\n\" + f'\\tdef {property}(cls) -> {return_template}:\\n\\t\\t\"\"\"\"\"\"\\n').replace(              \"\\t\", \"    \"          )          base_pyi += template + \"\\n\"      return base_pyi      def _build_header(filename):      _file = Path(filename)      return _file.read_text() + \"\\n\\n\"      if __name__ == \"__main__\":      header_file = \"stubs/pyi_header.py\"      config_init = Path(\"taipy-core/src/taipy/core/config/__init__.py\")      base_config = \"src/taipy/config/config.py\"        dn_filename = \"taipy-core/src/taipy/core/config/data_node_config.py\"      job_filename = \"taipy-core/src/taipy/core/config/job_config.py\"      scenario_filename = \"taipy-core/src/taipy/core/config/scenario_config.py\"      task_filename = \"taipy-core/src/taipy/core/config/task_config.py\"      migration_filename = \"taipy-core/src/taipy/core/config/migration_config.py\"      core_filename = \"taipy-core/src/taipy/core/config/core_section.py\"        entities_map, property_map = _generate_entity_and_property_maps(config_init)      pyi = _build_header(header_file)      pyi = _build_base_config_pyi(base_config, pyi)      pyi = _generate_acessors(pyi, property_map)      pyi = _build_entity_config_pyi(pyi, scenario_filename, entities_map[\"ScenarioConfig\"])      pyi = _build_entity_config_pyi(pyi, dn_filename, entities_map[\"DataNodeConfig\"])      pyi = _build_entity_config_pyi(pyi, task_filename, entities_map[\"TaskConfig\"])      pyi = _build_entity_config_pyi(pyi, job_filename, entities_map[\"JobConfig\"])      pyi = _build_entity_config_pyi(pyi, migration_filename, entities_map[\"MigrationConfig\"])      pyi = _build_entity_config_pyi(pyi, core_filename, entities_map[\"CoreSection\"])        with open(\"src/taipy/config/config.pyi\", \"w\") as f:          f.writelines(pyi) "}
{"text": "import json  from datetime import timedelta  from typing import Any, Callable, Dict, List, Optional, Union    from taipy.core.config import CoreSection, DataNodeConfig, JobConfig, MigrationConfig, ScenarioConfig, TaskConfig    from .checker.issue_collector import IssueCollector  from .common._classproperty import _Classproperty  from .common._config_blocker import _ConfigBlocker  from .common.frequency import Frequency  from .common.scope import Scope  from .global_app.global_app_config import GlobalAppConfig  from .section import Section  from .unique_section import UniqueSection "}
{"text": "import toml  # type: ignore    from .._config import _Config  from ..exceptions.exceptions import LoadingError  from ._base_serializer import _BaseSerializer      class _TomlSerializer(_BaseSerializer):      \"\"\"Convert configuration from TOML representation to Python Dict and reciprocally.\"\"\"        @classmethod      def _write(cls, configuration: _Config, filename: str):          with open(filename, \"w\") as fd:              toml.dump(cls._str(configuration), fd)        @classmethod      def _read(cls, filename: str) -> _Config:          try:              config_as_dict = cls._pythonify(dict(toml.load(filename)))              return cls._from_dict(config_as_dict)          except toml.TomlDecodeError as e:              error_msg = f\"Can not load configuration {e}\"              raise LoadingError(error_msg)        @classmethod      def _serialize(cls, configuration: _Config) -> str:          return toml.dumps(cls._str(configuration))        @classmethod      def _deserialize(cls, config_as_string: str) -> _Config:          return cls._from_dict(cls._pythonify(dict(toml.loads(config_as_string)))) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import json  # type: ignore    from .._config import _Config  from ..exceptions.exceptions import LoadingError  from ._base_serializer import _BaseSerializer      class _JsonSerializer(_BaseSerializer):      \"\"\"Convert configuration from JSON representation to Python Dict and reciprocally.\"\"\"        @classmethod      def _write(cls, configuration: _Config, filename: str):          with open(filename, \"w\") as fd:              json.dump(cls._str(configuration), fd, ensure_ascii=False, indent=0, check_circular=False)        @classmethod      def _read(cls, filename: str) -> _Config:          try:              with open(filename) as f:                  config_as_dict = cls._pythonify(json.load(f))              return cls._from_dict(config_as_dict)          except json.JSONDecodeError as e:              error_msg = f\"Can not load configuration {e}\"              raise LoadingError(error_msg)        @classmethod      def _serialize(cls, configuration: _Config) -> str:          return json.dumps(cls._str(configuration), ensure_ascii=False, indent=0, check_circular=False)        @classmethod      def _deserialize(cls, config_as_string: str) -> _Config:          return cls._from_dict(cls._pythonify(dict(json.loads(config_as_string)))) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from typing import Any, List    from .issue import Issue      class IssueCollector:      \"\"\"      A collection of issues (instances of class `Issue^`).        Attributes:          errors (List[Issue^]): List of ERROR issues collected.          warnings (List[Issue^]): List WARNING issues collected.          infos (List[Issue^]): List INFO issues collected.          all (List[Issue^]): List of all issues collected ordered by decreasing level (ERROR, WARNING and INFO).      \"\"\"        _ERROR_LEVEL = \"ERROR\"      _WARNING_LEVEL = \"WARNING\"      _INFO_LEVEL = \"INFO\"        def __init__(self):          self._errors: List[Issue] = []          self._warnings: List[Issue] = []          self._infos: List[Issue] = []        @property      def all(self) -> List[Issue]:          return self._errors + self._warnings + self._infos        @property      def infos(self) -> List[Issue]:          return self._infos        @property      def warnings(self) -> List[Issue]:          return self._warnings        @property      def errors(self) -> List[Issue]:          return self._errors        def _add_error(self, field: str, value: Any, message: str, checker_name: str):          self._errors.append(Issue(self._ERROR_LEVEL, field, value, message, checker_name))        def _add_warning(self, field: str, value: Any, message: str, checker_name: str):          self._warnings.append(Issue(self._WARNING_LEVEL, field, value, message, checker_name))        def _add_info(self, field: str, value: Any, message: str, checker_name: str):          self._infos.append(Issue(self._INFO_LEVEL, field, value, message, checker_name)) "}
{"text": "from dataclasses import dataclass  from typing import Any, Optional      @dataclass  class Issue:      \"\"\"      An issue detected in the configuration.        Attributes:          level (str): Level of the issue among ERROR, WARNING, INFO.          field (str): Configuration field on which the issue has been detected.          value (Any): Value of the field on which the issue has been detected.          message (str): Human readable message to help the user fix the issue.          tag (Optional[str]): Optional tag to be used to filter issues.      \"\"\"        level: str      field: str      value: Any      message: str      tag: Optional[str]        def __str__(self) -> str:          message = self.message            if self.value:              current_value_str = f'\"{self.value}\"' if isinstance(self.value, str) else f\"{self.value}\"              message += f\" Current value of property `{self.field}` is {current_value_str}.\"            return message "}
{"text": "from typing import List    from ._checkers._config_checker import _ConfigChecker  from .issue_collector import IssueCollector      class _Checker:      \"\"\"Holds the various checkers to perform on the config.\"\"\"        _checkers: List[_ConfigChecker] = []        @classmethod      def _check(cls, _applied_config):          collector = IssueCollector()          for checker in cls._checkers:              checker(_applied_config, collector)._check()          return collector        @classmethod      def add_checker(cls, checker_class: _ConfigChecker):          cls._checkers.append(checker_class) "}
{"text": "import abc  from typing import Any, List, Optional, Set    from ..._config import _Config  from ..issue_collector import IssueCollector      class _ConfigChecker:      _PREDEFINED_PROPERTIES_KEYS = [\"_entity_owner\"]        def __init__(self, config: _Config, collector):          self._collector = collector          self._config = config        @abc.abstractmethod      def _check(self) -> IssueCollector:          raise NotImplementedError        def _error(self, field: str, value: Any, message: str):          self._collector._add_error(field, value, message, self.__class__.__name__)        def _warning(self, field: str, value: Any, message: str):          self._collector._add_warning(field, value, message, self.__class__.__name__)        def _info(self, field: str, value: Any, message: str):          self._collector._add_info(field, value, message, self.__class__.__name__)        def _check_children(          self,          parent_config_class,          config_id: str,          config_key: str,          config_value,          child_config_class,          can_be_empty: Optional[bool] = False,      ):          if not config_value and not can_be_empty:              self._warning(                  config_key,                  config_value,                  f\"{config_key} field of {parent_config_class.__name__} `{config_id}` is empty.\",              )          else:              if not (                  (isinstance(config_value, List) or isinstance(config_value, Set))                  and all(map(lambda x: isinstance(x, child_config_class), config_value))              ):                  self._error(                      config_key,                      config_value,                      f\"{config_key} field of {parent_config_class.__name__} `{config_id}` must be populated with a list \"                      f\"of {child_config_class.__name__} objects.\",                  )        def _check_existing_config_id(self, config):          if not config.id:              self._error(                  \"config_id\",                  config.id,                  f\"config_id of {config.__class__.__name__} `{config.id}` is empty.\",              )        def _check_if_entity_property_key_used_is_predefined(self, config):          for key, value in config._properties.items():              if key in self._PREDEFINED_PROPERTIES_KEYS:                  self._error(                      key,                      value,                      f\"Properties of {config.__class__.__name__} `{config.id}` cannot have `{key}` as its property.\",                  ) "}
{"text": "from ..._config import _Config  from ..issue_collector import IssueCollector  from ._config_checker import _ConfigChecker      class _AuthConfigChecker(_ConfigChecker):      def __init__(self, config: _Config, collector: IssueCollector):          super().__init__(config, collector)        def _check(self) -> IssueCollector:          auth_config = self._config._auth_config  # type: ignore          self._check_predefined_protocol(auth_config)          return self._collector        def _check_predefined_protocol(self, auth_config):          if auth_config.protocol == auth_config._PROTOCOL_LDAP:              self.__check_ldap(auth_config)          if auth_config.protocol == auth_config._PROTOCOL_TAIPY:              self.__check_taipy(auth_config)        def __check_taipy(self, auth_config):          if auth_config._TAIPY_ROLES not in auth_config.properties:              self._error(                  \"properties\",                  auth_config._LDAP_SERVER,                  f\"`{auth_config._LDAP_SERVER}` property must be populated when {auth_config._PROTOCOL_LDAP} is used.\",              )          if auth_config._TAIPY_PWD not in auth_config.properties:              self._warning(                  \"properties\",                  auth_config._TAIPY_PWD,                  f\"`In order to protect authentication with passwords using {auth_config._PROTOCOL_TAIPY} protocol,\"                  f\" {auth_config._TAIPY_PWD}` property can be populated.\",              )        def __check_ldap(self, auth_config):          if auth_config._LDAP_SERVER not in auth_config.properties:              self._error(                  \"properties\",                  auth_config._LDAP_SERVER,                  f\"`{auth_config._LDAP_SERVER}` attribute must be populated when {auth_config._PROTOCOL_LDAP} is used.\",              )          if auth_config._LDAP_BASE_DN not in auth_config.properties:              self._error(                  \"properties\",                  auth_config._LDAP_BASE_DN,                  f\"`{auth_config._LDAP_BASE_DN}` field must be populated when {auth_config._PROTOCOL_LDAP} is used.\",              ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "# Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.    from .exceptions import * "}
{"text": "  class LoadingError(Exception):      \"\"\"Raised if an error occurs while loading the configuration file.\"\"\"      class InconsistentEnvVariableError(Exception):      \"\"\"Inconsistency value has been detected in an environment variable referenced by the configuration.\"\"\"      class MissingEnvVariableError(Exception):      \"\"\"Environment variable referenced in configuration is missing.\"\"\"      class InvalidConfigurationId(Exception):      \"\"\"Configuration id is not valid.\"\"\"      class ConfigurationUpdateBlocked(Exception):      \"\"\"The configuration is being blocked from update by other Taipy services.\"\"\" "}
{"text": "from ..common._repr_enum import _ReprEnum      class Frequency(_ReprEnum):      \"\"\"Frequency of the recurrence of `Cycle^` and `Scenario^` objects.        The frequency must be provided in the `ScenarioConfig^`.        Each recurrent scenario is attached to the cycle corresponding to the creation date and the      frequency. In other words, each cycle represents an iteration and contains the various scenarios      created during this iteration.        For instance, when scenarios have a _MONTHLY_ frequency, one cycle will be created for each      month (January, February, March, etc.). A new scenario created on February 10th, gets      attached to the _February_ cycle.        The frequency is implemented as an enumeration with the following possible values:        - With a _DAILY_ frequency, a new cycle is created for each day.        - With a _WEEKLY_ frequency, a new cycle is created for each week (from Monday to Sunday).        - With a _MONTHLY_ frequency, a new cycle is created for each month.        - With a _QUARTERLY_ frequency, a new cycle is created for each quarter.        - With a _YEARLY_ frequency, a new cycle is created for each year.      \"\"\"        DAILY = 1      WEEKLY = 2      MONTHLY = 3      QUARTERLY = 4      YEARLY = 5 "}
{"text": "  class _Classproperty(object):      def __init__(self, f):          self.f = f        def __get__(self, obj, owner):          return self.f(owner) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import functools  from enum import Enum      class _ReprEnum(Enum):      @classmethod      @functools.lru_cache      def _from_repr(cls, repr_: str):          return next(filter(lambda e: repr(e) == repr_, cls))  # type: ignore "}
{"text": "import keyword    from ..exceptions.exceptions import InvalidConfigurationId    __INVALID_TAIPY_ID_TERMS = [\"CYCLE\", \"SCENARIO\", \"SEQUENCE\", \"TASK\", \"DATANODE\"]      def _validate_id(name: str):      for invalid_taipy_id_term in __INVALID_TAIPY_ID_TERMS:          if invalid_taipy_id_term in name:              raise InvalidConfigurationId(f\"{name} is not a valid identifier. {invalid_taipy_id_term} is restricted.\")        if name.isidentifier() and not keyword.iskeyword(name):          return name        raise InvalidConfigurationId(f\"{name} is not a valid identifier.\") "}
{"text": "import functools    from ...logger._taipy_logger import _TaipyLogger  from ..exceptions.exceptions import ConfigurationUpdateBlocked      class _ConfigBlocker:      \"\"\"Configuration blocker singleton.\"\"\"        __logger = _TaipyLogger._get_logger()      __block_config_update = False        @classmethod      def _block(cls):          cls.__block_config_update = True        @classmethod      def _unblock(cls):          cls.__block_config_update = False        @classmethod      def _check(cls):          def inner(f):              @functools.wraps(f)              def _check_if_is_blocking(*args, **kwargs):                  if cls.__block_config_update:                      error_message = (                          \"The Core service should be stopped by running core.stop() before\"                          \" modifying the Configuration. For more information, please refer to:\"                          \" https://docs.taipy.io/en/latest/manuals/running_services/#running-core.\"                      )                      cls.__logger.error(\"ConfigurationUpdateBlocked: \" + error_message)                      raise ConfigurationUpdateBlocked(error_message)                    return f(*args, **kwargs)                return _check_if_is_blocking            return inner "}
{"text": "from ..common._repr_enum import _ReprEnum      class _OrderedEnum(_ReprEnum):      def __ge__(self, other):          if self.__class__ is other.__class__:              return self.value >= other.value          return NotImplemented        def __gt__(self, other):          if self.__class__ is other.__class__:              return self.value > other.value          return NotImplemented        def __le__(self, other):          if self.__class__ is other.__class__:              return self.value <= other.value          return NotImplemented        def __lt__(self, other):          if self.__class__ is other.__class__:              return self.value < other.value          return NotImplemented      class Scope(_OrderedEnum):      \"\"\"Scope of a `DataNode^`.        This enumeration can have the following values:        - `GLOBAL`      - `CYCLE`      - `SCENARIO`      \"\"\"        GLOBAL = 3      CYCLE = 2      SCENARIO = 1 "}
{"text": "import os  import re  from collections import UserDict  from datetime import datetime, timedelta  from importlib import import_module  from operator import attrgetter  from pydoc import locate    from ..exceptions.exceptions import InconsistentEnvVariableError, MissingEnvVariableError  from .frequency import Frequency  from .scope import Scope      class _TemplateHandler:      \"\"\"Factory to handle actions related to config value templating.\"\"\"        _PATTERN = r\"^ENV\\[([a-zA-Z_]\\w*)\\](:(\\bbool\\b|\\bstr\\b|\\bfloat\\b|\\bint\\b))?$\"        @classmethod      def _replace_templates(cls, template, type=str, required=True, default=None):          if isinstance(template, tuple):              return tuple(cls._replace_template(item, type, required, default) for item in template)          if isinstance(template, list):              return [cls._replace_template(item, type, required, default) for item in template]          if isinstance(template, dict):              return {str(k): cls._replace_template(v, type, required, default) for k, v in template.items()}          if isinstance(template, UserDict):              return {str(k): cls._replace_template(v, type, required, default) for k, v in template.items()}          return cls._replace_template(template, type, required, default)        @classmethod      def _replace_template(cls, template, type, required, default):          if \"ENV\" not in str(template):              return template          match = re.fullmatch(cls._PATTERN, str(template))          if match:              var = match.group(1)              dynamic_type = match.group(3)              val = os.environ.get(var)              if val is None:                  if required:                      raise MissingEnvVariableError(f\"Environment variable {var} is not set.\")                  return default              if type == bool:                  return cls._to_bool(val)              elif type == int:                  return cls._to_int(val)              elif type == float:                  return cls._to_float(val)              elif type == Scope:                  return cls._to_scope(val)              elif type == Frequency:                  return cls._to_frequency(val)              else:                  if dynamic_type == \"bool\":                      return cls._to_bool(val)                  elif dynamic_type == \"int\":                      return cls._to_int(val)                  elif dynamic_type == \"float\":                      return cls._to_float(val)                  return val          return template        @staticmethod      def _to_bool(val: str) -> bool:          possible_values = [\"true\", \"false\"]          if str.lower(val) not in possible_values:              raise InconsistentEnvVariableError(\"{val} is not a Boolean.\")          return str.lower(val) == \"true\" or not (str.lower(val) == \"false\")        @staticmethod      def _to_int(val: str) -> int:          try:              return int(val)          except ValueError:              raise InconsistentEnvVariableError(f\"{val} is not an integer.\")        @staticmethod      def _to_float(val: str) -> float:          try:              return float(val)          except ValueError:              raise InconsistentEnvVariableError(f\"{val} is not a float.\")        @staticmethod      def _to_datetime(val: str) -> datetime:          try:              return datetime.fromisoformat(val)          except ValueError:              raise InconsistentEnvVariableError(f\"{val} is not a valid datetime.\")        @staticmethod      def _to_timedelta(val: str) -> timedelta:          \"\"\"          Parse a time string e.g. (2h13m) into a timedelta object.            :param timedelta_str: A string identifying a duration.  (eg. 2h13m)          :return datetime.timedelta: A datetime.timedelta object          \"\"\"          regex = re.compile(              r\"^((?P<days>[\\.\\d]+?)d)? *\"              r\"((?P<hours>[\\.\\d]+?)h)? *\"              r\"((?P<minutes>[\\.\\d]+?)m)? *\"              r\"((?P<seconds>[\\.\\d]+?)s)?$\"          )          parts = regex.match(val)          if not parts:              raise InconsistentEnvVariableError(f\"{val} is not a valid timedelta.\")          time_params = {name: float(param) for name, param in parts.groupdict().items() if param}          return timedelta(**time_params)  # type: ignore        @staticmethod      def _to_scope(val: str) -> Scope:          try:              return Scope[str.upper(val)]          except Exception:              raise InconsistentEnvVariableError(f\"{val} is not a valid scope.\")        @staticmethod      def _to_frequency(val: str) -> Frequency:          try:              return Frequency[str.upper(val)]          except Exception:              raise InconsistentEnvVariableError(f\"{val} is not a valid frequency.\")        @staticmethod      def _to_function(val: str):          module_name, fct_name = val.rsplit(\".\", 1)          try:              module = import_module(module_name)              return attrgetter(fct_name)(module)          except Exception:              raise InconsistentEnvVariableError(f\"{val} is not a valid function.\")        @staticmethod      def _to_class(val: str):          try:              return locate(val)          except Exception:              raise InconsistentEnvVariableError(f\"{val} is not a valid class.\") "}
{"text": ""}
{"text": "from __future__ import annotations    from typing import Any, Dict, Optional, Union    from ..common._config_blocker import _ConfigBlocker  from ..common._template_handler import _TemplateHandler as _tpl      class GlobalAppConfig:      \"\"\"      Configuration fields related to the global application.        Attributes:          **properties (Dict[str, Any]): A dictionary of additional properties.      \"\"\"        def __init__(self, **properties):          self._properties = properties        @property      def properties(self):          return {k: _tpl._replace_templates(v) for k, v in self._properties.items()}        @properties.setter  # type: ignore      @_ConfigBlocker._check()      def properties(self, val):          self._properties = val        def __getattr__(self, item: str) -> Optional[Any]:          return _tpl._replace_templates(self._properties.get(item))        @classmethod      def default_config(cls) -> GlobalAppConfig:          return GlobalAppConfig()        def _clean(self):          self._properties.clear()        def _to_dict(self):          as_dict = {}          as_dict.update(self._properties)          return as_dict        @classmethod      def _from_dict(cls, config_as_dict: Dict[str, Any]):          config = GlobalAppConfig()          config._properties = config_as_dict          return config        def _update(self, config_as_dict):          self._properties.update(config_as_dict) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import pathlib  import sys    from cookiecutter.main import cookiecutter    import taipy  from taipy._cli._base_cli import _CLI      class _ScaffoldCLI:      __TAIPY_PATH = pathlib.Path(taipy.__file__).parent.resolve() / \"templates\"        _TEMPLATE_MAP = {str(x.name): str(x) for x in __TAIPY_PATH.iterdir() if x.is_dir()}        @classmethod      def create_parser(cls):          create_parser = _CLI._add_subparser(\"create\", help=\"Create a new Taipy application.\")          create_parser.add_argument(              \"--template\",              choices=list(cls._TEMPLATE_MAP.keys()),              default=\"default\",              help=\"The Taipy template to create new application.\",          )        @classmethod      def parse_arguments(cls):          args = _CLI._parse()            if getattr(args, \"which\", None) == \"create\":              cookiecutter(cls._TEMPLATE_MAP[args.template])              sys.exit(0) "}
{"text": "import subprocess  import sys    from taipy._cli._base_cli import _CLI      class _RunCLI:      @classmethod      def create_parser(cls):          run_parser = _CLI._add_subparser(\"run\", help=\"Run a Taipy application.\")          run_parser.add_argument(              \"application_main_file\",          )            sub_run_parser = run_parser.add_subparsers(title=\"subcommands\")          sub_run_parser.add_parser(              \"external-args\",              help=\"\"\"                  Arguments defined after this keyword will be considered as external arguments                  to be passed to the application              \"\"\",          )        @classmethod      def parse_arguments(cls):          args = _CLI._parse()            if getattr(args, \"which\", None) == \"run\":              all_args = sys.argv[3:]  # First 3 args are always (1) Python executable, (2) run, (3) Python file                external_args = []              try:                  external_args_index = all_args.index(\"external-args\")              except ValueError:                  pass              else:                  external_args.extend(all_args[external_args_index + 1 :])                  all_args = all_args[:external_args_index]                taipy_args = [f\"--taipy-{arg[2:]}\" if arg.startswith(\"--\") else arg for arg in all_args]                subprocess.run(                  [sys.executable, args.application_main_file, *(external_args + taipy_args)],                  stdout=sys.stdout,                  stderr=sys.stdout,              )                sys.exit(0) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import sys    from taipy._cli._base_cli import _CLI  from taipy.logger._taipy_logger import _TaipyLogger      class _HelpCLI:      __logger = _TaipyLogger._get_logger()        @classmethod      def create_parser(cls):          create_parser = _CLI._add_subparser(\"help\", help=\"Show the Taipy help message.\", add_help=False)          create_parser.add_argument(              \"command\", nargs=\"?\", type=str, const=\"\", default=\"\", help=\"Show the help message of the command.\"          )        @classmethod      def parse_arguments(cls):          args = _CLI._parse()            if getattr(args, \"which\", None) == \"help\":              if args.command:                  if args.command in _CLI._sub_taipyparsers.keys():                      _CLI._sub_taipyparsers.get(args.command).print_help()                  else:                      cls.__logger.error(f\"{args.command} is not a valid command.\")              else:                  _CLI._parser.print_help()                sys.exit(0) "}
{"text": "import argparse  from typing import Dict      class _CLI:      \"\"\"Argument parser for Taipy application.\"\"\"        # The conflict_handler is set to \"resolve\" to override conflict arguments      _subparser_action = None      _parser = argparse.ArgumentParser(conflict_handler=\"resolve\")        _sub_taipyparsers: Dict[str, argparse.ArgumentParser] = {}      _arg_groups: Dict[str, argparse._ArgumentGroup] = {}        @classmethod      def _add_subparser(cls, name: str, **kwargs) -> argparse.ArgumentParser:          \"\"\"Create a new subparser and return a argparse handler.\"\"\"          if subparser := cls._sub_taipyparsers.get(name):              return subparser            if not cls._subparser_action:              cls._subparser_action = cls._parser.add_subparsers()            subparser = cls._subparser_action.add_parser(              name=name,              conflict_handler=\"resolve\",              **kwargs,          )          cls._sub_taipyparsers[name] = subparser          subparser.set_defaults(which=name)          return subparser        @classmethod      def _add_groupparser(cls, title: str, description: str = \"\") -> argparse._ArgumentGroup:          \"\"\"Create a new group for arguments and return a argparser handler.\"\"\"          if groupparser := cls._arg_groups.get(title):              return groupparser            groupparser = cls._parser.add_argument_group(title=title, description=description)          cls._arg_groups[title] = groupparser          return groupparser        @classmethod      def _parse(cls):          \"\"\"Parse and return only known arguments.\"\"\"          args, _ = cls._parser.parse_known_args()          return args        @classmethod      def _remove_argument(cls, arg: str):          \"\"\"Remove an argument from the parser. Note that the `arg` must be without --.            Source: https://stackoverflow.com/questions/32807319/disable-remove-argument-in-argparse          \"\"\"          for action in cls._parser._actions:              opts = action.option_strings              if (opts and opts[0] == arg) or action.dest == arg:                  cls._parser._remove_action(action)                  break            for argument_group in cls._parser._action_groups:              for group_action in argument_group._group_actions:                  opts = group_action.option_strings                  if (opts and opts[0] == arg) or group_action.dest == arg:                      argument_group._group_actions.remove(group_action)                      return "}
{"text": "from ._cli import _CLI "}
{"text": "import typing as t      class Icon:      \"\"\"Small image in the User Interface.        Icons are typically used in controls like [button](../gui/viselements/button.md)      or items in a [menu](../gui/viselements/menu.md).        Attributes:          path (str): The path to the image file.          text (Optional[str]): The text associated to the image or None if there is none.          svg (Optional[bool]): True if the image is svg.        If a text is associated to an icon, it is rendered by the visual elements that      uses this Icon.      \"\"\"        @staticmethod      def get_dict_or(value: t.Union[str, t.Any]) -> t.Union[str, dict]:          return value._to_dict() if isinstance(value, Icon) else value        def __init__(          self,          path: str,          text: t.Optional[str] = None,          light_path: t.Optional[bool] = None,          dark_path: t.Optional[bool] = None,      ) -> None:          \"\"\"Initialize a new Icon.            Arguments:              path (str): The path to an image file.<br/>                  This path must be relative to and inside the root directory of the                  application (where the Python file that created the `Gui` instance                  is located).<br/>                  In situations where the image file is located outside the application                  directory, a _path mapping_ must be used: the _path_mapping_ parameter                  of the `Gui^` constructor makes it possible to access a resource anywhere                  on the server filesystem, as if it were located in a subdirectory of                  the application directory.              text (Optional[str]): The text associated to the image. If *text* is None,                  there is no text associated to this image.              light_path (Optional[str]): The path to the light theme image (fallback to *path* if not defined).              dark_path (Optional[str]): The path to the dark theme image (fallback to *path* if not defined).          \"\"\"          self.path = path          self.text = text          if light_path is not None:              self.light_path = light_path          if dark_path is not None:              self.dark_path = dark_path        def _to_dict(self, a_dict: t.Optional[dict] = None) -> dict:          if a_dict is None:              a_dict = {}          a_dict[\"path\"] = self.path          if self.text is not None:              a_dict[\"text\"] = self.text          if hasattr(self, \"light_path\") and self.light_path is not None:              a_dict[\"lightPath\"] = self.light_path          if hasattr(self, \"dark_path\") and self.dark_path is not None:              a_dict[\"darkPath\"] = self.dark_path          return a_dict "}
{"text": "from .gui import Gui "}
{"text": "import typing as t  from enum import Enum  from inspect import isclass    from .data import Decimator  from .utils import (      _TaipyBase,      _TaipyBool,      _TaipyContent,      _TaipyContentHtml,      _TaipyContentImage,      _TaipyData,      _TaipyDate,      _TaipyDateRange,      _TaipyDict,      _TaipyLoNumbers,      _TaipyLov,      _TaipyLovValue,      _TaipyNumber,  )      class _WsType(Enum):      ACTION = \"A\"      MULTIPLE_UPDATE = \"MU\"      REQUEST_UPDATE = \"RU\"      DATA_UPDATE = \"DU\"      UPDATE = \"U\"      ALERT = \"AL\"      BLOCK = \"BL\"      NAVIGATE = \"NA\"      CLIENT_ID = \"ID\"      MULTIPLE_MESSAGE = \"MS\"      DOWNLOAD_FILE = \"DF\"      PARTIAL = \"PR\"      ACKNOWLEDGEMENT = \"ACK\"      NumberTypes = {\"int\", \"int64\", \"float\", \"float64\"}      class PropertyType(Enum):      \"\"\"      All the possible element property types.        This is used when creating custom visual elements, where you have      to indicate the type of each property.        Some types are 'dynamic', meaning that if the property value is modified, it      is automatically handled by Taipy and propagated to the entire application.        See `ElementProperty^` for more details.      \"\"\"        boolean = \"boolean\"      \"\"\"      The property holds a Boolean value.      \"\"\"      toHtmlContent = _TaipyContentHtml      content = _TaipyContent      data = _TaipyData      date = _TaipyDate      date_range = _TaipyDateRange      dict = \"dict\"      \"\"\"      The property holds a dictionary.      \"\"\"      dynamic_dict = _TaipyDict      \"\"\"      The property holds a dynamic dictionary.      \"\"\"      dynamic_number = _TaipyNumber      \"\"\"      The property holds a dynamic number.      \"\"\"      dynamic_lo_numbers = _TaipyLoNumbers      \"\"\"      The property holds a dynamic list of numbers.      \"\"\"      dynamic_boolean = _TaipyBool      \"\"\"      The property holds a dynamic Boolean value.      \"\"\"      dynamic_list = \"dynamiclist\"      dynamic_string = \"dynamicstring\"      \"\"\"      The property holds a dynamic string.      \"\"\"      function = \"function\"      \"\"\"      The property holds a reference to a function.      \"\"\"      image = _TaipyContentImage      json = \"json\"      lov = _TaipyLov      \"\"\"      The property holds a LoV (list of values).      \"\"\"      lov_value = _TaipyLovValue      \"\"\"      The property holds a value in a LoV (list of values).      \"\"\"      number = \"number\"      \"\"\"      The property holds a number.      \"\"\"      react = \"react\"      broadcast = \"broadcast\"      string = \"string\"      \"\"\"      The property holds a string.      \"\"\"      string_or_number = \"string|number\"      \"\"\"      The property holds a string or a number.        This is typically used to handle CSS dimension values, where a unit can be used.      \"\"\"      boolean_or_list = \"boolean|list\"      slider_value = \"number|number[]|lovValue\"      string_list = \"stringlist\"      decimator = Decimator      \"\"\"      The property holds an inner attributes that is defined by a library and cannot be overridden by the user.      \"\"\"      inner = \"inner\"      @t.overload  # noqa: F811  def _get_taipy_type(a_type: None) -> None:      ...      @t.overload  def _get_taipy_type(a_type: t.Type[_TaipyBase]) -> t.Type[_TaipyBase]:  # noqa: F811      ...      @t.overload  def _get_taipy_type(a_type: PropertyType) -> t.Type[_TaipyBase]:  # noqa: F811      ...      @t.overload  def _get_taipy_type(  # noqa: F811      a_type: t.Optional[t.Union[t.Type[_TaipyBase], t.Type[Decimator], PropertyType]]  ) -> t.Optional[t.Union[t.Type[_TaipyBase], t.Type[Decimator], PropertyType]]:      ...      def _get_taipy_type(  # noqa: F811      a_type: t.Optional[t.Union[t.Type[_TaipyBase], t.Type[Decimator], PropertyType]]  ) -> t.Optional[t.Union[t.Type[_TaipyBase], t.Type[Decimator], PropertyType]]:      if a_type is None:          return None      if isinstance(a_type, PropertyType) and not isinstance(a_type.value, str):          return a_type.value      if isclass(a_type) and not isinstance(a_type, PropertyType) and issubclass(a_type, _TaipyBase):          return a_type      if a_type == PropertyType.boolean:          return _TaipyBool      elif a_type == PropertyType.number:          return _TaipyNumber      return None "}
{"text": "\"\"\"# Taipy Graphical User Interface generator    The Taipy GUI package provides User Interface generation based on page templates. It can  run a web server that a web browser can connect to.    The pages are generated by a web server that allows web clients to connect, display and  interact with the page content through visual elements.    Each page can contain regular text and images, as well as Taipy controls that are  typically linked to some value that is managed by the whole Taipy application.    Here is how you can create your first Taipy User Interface:       - Create a Python source file.       Copy these two lines into a file called *taipy_app.py*.       ```py title=\"taipy_app.py\"       from taipy import Gui       Gui(\"# Hello Taipy!\").run()       ```     - Install Taipy:       ```       pip install taipy       ```     - Run your application:       ```       python taipy_app.py       ```    Your browser opens a new page, showing the content of your graphical  application.    !!! Note \"Optional packages\"        There are Python packages that you can install in your environment to      add functionality to Taipy GUI:        - [`python-magic`](https://pypi.org/project/python-magic/): identifies image format        from byte buffers so the [`image`](../../gui/viselements/image.md) control can        display them, and so that [`file_download`](../../gui/viselements/file_download.md)        can request the browser to display the image content when relevant.<br/>        You can install that package with the regular `pip install python-magic` command        (then potentially `pip install python-magic` on Windows),        or install Taipy GUI using: `pip install taipy-gui[image]`.      - [`pyarrow`](https://pypi.org/project/pyarrow/): can improve the performance of your        application by reducing the volume of data transferred between the web server and the        clients. This is relevant if your application uses large tabular data.<br/>        You can install that package with the regular `pip install pyarrow` command,        or install Taipy GUI using: `pip install taipy-gui[arrow]`.      - [`simple-websocket`](https://pypi.org/project/simple-websocket/): enables the        debugging of the WebSocket part of the server execution.<br/>        You can install that package with the regular `pip install simple-websocket` command,        or install Taipy GUI using: `pip install taipy-gui[simple-websocket]`.      - [`pyngrok`](https://pypi.org/project/pyngrok/): enables use of [Ngrok](https://ngrok.com/)        to access Taipy GUI application from the internet.<br/>        You can install that package with the regular `pip install pyngrok` command,        or install Taipy GUI using: `pip install taipy-gui[pyngrok]`.    \"\"\"    from importlib.util import find_spec    from ._init import *  from ._renderers import Html, Markdown  from .gui_actions import (      broadcast_callback,      download,      get_module_context,      get_module_name_from_state,      get_state_id,      get_user_content_url,      hold_control,      invoke_callback,      invoke_long_callback,      navigate,      notify,      resume_control,  )  from .icon import Icon  from .page import Page  from .partial import Partial  from .state import State  from .utils import is_debugging    if find_spec(\"taipy\") and find_spec(\"taipy.config\"):      from taipy.config import _inject_section        from ._default_config import default_config      from ._gui_section import _GuiSection        _inject_section(          _GuiSection,          \"gui_config\",          _GuiSection(property_list=list(default_config)),          [(\"configure_gui\", _GuiSection._configure)],          add_to_unconflicted_sections=True,      ) "}
{"text": "from __future__ import annotations    import inspect  import typing as t  from types import FrameType    from .utils import _filter_locals, _get_module_name_from_frame    if t.TYPE_CHECKING:      from ._renderers import _Element      class Page:      \"\"\"Generic page generator.        The `Page` class transforms template text into actual pages that can be displayed      on a web browser.        When a page is requested to be displayed, it is converted into HTML      code that can be sent to the client. All control placeholders are      replaced by their respective graphical component so you can show      your application variables and interact with them.      \"\"\"        def __init__(self, **kwargs) -> None:          self._class_module_name = \"\"          self._class_locals: t.Dict[str, t.Any] = {}          self._frame: t.Optional[FrameType] = None          self._renderer: t.Optional[Page] = self.create_page()          if \"frame\" in kwargs:              self._frame = kwargs.get(\"frame\")          elif self._renderer:              self._frame = self._renderer._frame          elif len(inspect.stack()) < 4:              raise RuntimeError(f\"Can't resolve module. Page '{type(self).__name__}' is not registered.\")          else:              self._frame = t.cast(FrameType, t.cast(FrameType, inspect.stack()[3].frame))          if self._renderer:              # Extract the page module's attributes and methods              cls = type(self)              cls_locals = dict(vars(self))              funcs = [                  i[0]                  for i in inspect.getmembers(cls)                  if not i[0].startswith(\"_\") and (inspect.ismethod(i[1]) or inspect.isfunction(i[1]))              ]              for f in funcs:                  func = getattr(self, f)                  if hasattr(func, \"__func__\") and func.__func__ is not None:                      cls_locals[f] = func.__func__              self._class_module_name = cls.__name__              self._class_locals = cls_locals        def create_page(self) -> t.Optional[Page]:          \"\"\"Create the page content for page modules.            If this page is a page module, this method must be overloaded and return the page content.            This method should never be called directly: only the Taipy GUI internals will.            The default implementation returns None, indicating that this class does not implement          a page module.            Returns:              The page content for this Page subclass, making it a page module.          \"\"\"          return None        def _get_locals(self) -> t.Optional[t.Dict[str, t.Any]]:          return (              self._class_locals              if self._is_class_module()              else None              if (frame := self._get_frame()) is None              else _filter_locals(frame.f_locals)          )        def _is_class_module(self):          return self._class_module_name != \"\"        def _get_frame(self):          if not hasattr(self, \"_frame\"):              raise RuntimeError(f\"Page '{type(self).__name__}' was not registered correctly.\")          return self._frame        def _get_module_name(self) -> t.Optional[str]:          return (              None              if (frame := self._get_frame()) is None              else f\"{_get_module_name_from_frame(frame)}{'.' if self._class_module_name else ''}{self._class_module_name}\"  # noqa: E501          )        def _get_content_detail(self, gui) -> str:          return f\"in class {type(self).__name__}\"        def render(self, gui) -> str:          if self._renderer is not None:              return self._renderer.render(gui)          return \"<h1>No renderer found for page</h1>\" "}
{"text": "import sys  import traceback  import typing as t  import warnings      class TaipyGuiWarning(UserWarning):      \"\"\"NOT DOCUMENTED        Warning category for Taipy warnings generated in user code.      \"\"\"        _tp_debug_mode = False        @staticmethod      def set_debug_mode(debug_mode: bool):          TaipyGuiWarning._tp_debug_mode = (              debug_mode if debug_mode else hasattr(sys, \"gettrace\") and sys.gettrace() is not None          )      def _warn(message: str, e: t.Optional[BaseException] = None):      warnings.warn(          f\"{message}:\\n{''.join(traceback.format_exception(type(e), e, e.__traceback__))}\"          if e and TaipyGuiWarning._tp_debug_mode          else f\"{message}:\\n{e}\"          if e          else message,          TaipyGuiWarning,          stacklevel=2,      ) "}
{"text": "import typing as t  from copy import copy    from taipy.config import Config as TaipyConfig  from taipy.config import UniqueSection    from ._default_config import default_config      class _GuiSection(UniqueSection):      name = \"gui\"        def __init__(self, property_list: t.Optional[t.List] = None, **properties):          self._property_list = property_list          super().__init__(**properties)        def __copy__(self):          return _GuiSection(property_list=copy(self._property_list), **copy(self._properties))        def _clean(self):          self._properties.clear()        def _to_dict(self):          as_dict = {}          as_dict.update(self._properties)          return as_dict        @classmethod      def _from_dict(cls, as_dict: t.Dict[str, t.Any], *_):          return _GuiSection(property_list=list(default_config), **as_dict)        def _update(self, as_dict: t.Dict[str, t.Any]):          if self._property_list:              as_dict = {k: v for k, v in as_dict.items() if k in self._property_list}          self._properties.update(as_dict)        @staticmethod      def _configure(**properties) -> \"_GuiSection\":          \"\"\"NOT DOCUMENTED          Configure the Graphical User Interface.            Parameters:              **properties (dict[str, any]): Keyword arguments that configure the behavior of the `Gui^` instances.<br/>                  Please refer to the                  [Configuration section](../gui/configuration.md#configuring-the-gui-instance)                  of the User Manual for more information on the accepted arguments.          Returns:              The GUI configuration.            \"\"\"          section = _GuiSection(property_list=list(default_config), **properties)          TaipyConfig._register(section)          return TaipyConfig.unique_sections[_GuiSection.name] "}
{"text": "# _Page for multipage support  from __future__ import annotations    import logging  import typing as t  import warnings    if t.TYPE_CHECKING:      from ._renderers import Page      from .gui import Gui      class _Page(object):      def __init__(self):          self._rendered_jsx: t.Optional[str] = None          self._renderer: t.Optional[Page] = None          self._style: t.Optional[str] = None          self._route: t.Optional[str] = None          self._head: t.Optional[list] = None        def render(self, gui: Gui):          if self._renderer is None:              raise RuntimeError(f\"Can't render page {self._route}: no renderer found\")          with warnings.catch_warnings(record=True) as w:              warnings.resetwarnings()              with gui._set_locals_context(self._renderer._get_module_name()):                  self._rendered_jsx = self._renderer.render(gui)              if w:                  s = \"\\033[1;31m\\n\"                  s += (                      message := f\"--- {len(w)} warning(s) were found for page '{'/' if self._route == gui._get_root_page_name() else self._route}' {self._renderer._get_content_detail(gui)} ---\\n\"  # noqa: E501                  )                  for i, wm in enumerate(w):                      s += f\" - Warning {i + 1}: {wm.message}\\n\"                  s += \"-\" * len(message)                  s += \"\\033[0m\\n\"                  logging.warn(s)          if hasattr(self._renderer, \"head\"):              self._head = list(self._renderer.head)  # type: ignore          # return renderer module_name from frame          return self._renderer._get_module_name() "}
{"text": "#!/usr/bin/env python    \"\"\"The setup script.\"\"\"    import json  import os  from pathlib import Path    from setuptools import find_namespace_packages, find_packages, setup  from setuptools.command.build_py import build_py    readme = Path(\"README.md\").read_text()    with open(f\"src{os.sep}taipy{os.sep}gui{os.sep}version.json\") as version_file:      version = json.load(version_file)      version_string = f'{version.get(\"major\", 0)}.{version.get(\"minor\", 0)}.{version.get(\"patch\", 0)}'      if vext := version.get(\"ext\"):          version_string = f\"{version_string}.{vext}\"    requirements = [      \"flask>=3.0.0,<3.1\",      \"flask-cors>=4.0.0,<5.0\",      \"flask-socketio>=5.3.6,<6.0\",      \"markdown>=3.4.4,<4.0\",      \"pandas>=2.0.0,<3.0\",      \"python-dotenv>=1.0.0,<1.1\",      \"pytz>=2021.3,<2022.2\",      \"tzlocal>=3.0,<5.0\",      \"backports.zoneinfo>=0.2.1,<0.3;python_version<'3.9'\",      \"gevent>=23.7.0,<24.0\",      \"gevent-websocket>=0.10.1,<0.11\",      \"kthread>=0.2.3,<0.3\",      \"taipy-config@git+https://git@github.com/Avaiga/taipy-config.git@develop\",      \"gitignore-parser>=0.1,<0.2\",      \"simple-websocket>=0.10.1,<1.0\",      \"twisted>=23.8.0,<24.0\",  ]    test_requirements = [\"pytest>=3.8\"]    extras_require = {      \"ngrok\": [\"pyngrok>=5.1,<6.0\"],      \"image\": [          \"python-magic>=0.4.24,<0.5;platform_system!='Windows'\",          \"python-magic-bin>=0.4.14,<0.5;platform_system=='Windows'\",      ],      \"arrow\": [\"pyarrow>=10.0.1,<11.0\"],  }      def _build_webapp():      already_exists = Path(\"./src/taipy/gui/webapp/index.html\").exists()      if not already_exists:          os.system(\"cd ../../../frontend/taipy-gui/dom && npm ci\")          os.system(\"cd ../../../frontend/taipy-gui && npm ci --omit=optional && npm run build\")      class NPMInstall(build_py):      def run(self):          _build_webapp()          build_py.run(self)      setup(      author=\"Avaiga\",      author_email=\"dev@taipy.io\",      python_requires=\">=3.8\",      classifiers=[          \"Intended Audience :: Developers\",          \"License :: OSI Approved :: Apache Software License\",          \"Natural Language :: English\",          \"Programming Language :: Python :: 3\",          \"Programming Language :: Python :: 3.8\",          \"Programming Language :: Python :: 3.9\",          \"Programming Language :: Python :: 3.10\",          \"Programming Language :: Python :: 3.11\",      ],      description=\"Low-code library to create graphical user interfaces on the Web for your Python applications.\",      long_description=readme,      long_description_content_type=\"text/markdown\",      install_requires=requirements,      license=\"Apache License 2.0\",      include_package_data=True,      keywords=\"taipy-gui\",      name=\"taipy-gui\",      package_dir={\"\": \"src\"},      packages=find_namespace_packages(where=\"src\") + find_packages(include=[\"taipy\", \"taipy.gui\", \"taipy.gui.*\"]),      test_suite=\"tests\",      tests_require=test_requirements,      url=\"https://github.com/avaiga/taipy-gui\",      version=version_string,      zip_safe=False,      extras_require=extras_require,      cmdclass={\"build_py\": NPMInstall},  ) "}
{"text": "from .config import Config, Stylekit    _default_stylekit: Stylekit = {      # Primary and secondary colors      \"color_primary\": \"#ff6049\",      \"color_secondary\": \"#293ee7\",      # Contextual color      \"color_error\": \"#FF595E\",      \"color_warning\": \"#FAA916\",      \"color_success\": \"#96E6B3\",      # Background and elevation color for LIGHT MODE      \"color_background_light\": \"#f0f5f7\",      \"color_paper_light\": \"#ffffff\",      # Background and elevation color for DARK MODE      \"color_background_dark\": \"#152335\",      \"color_paper_dark\": \"#1f2f44\",      # DEFINING FONTS      # Set main font family      \"font_family\": \"Lato, Arial, sans-serif\",      # DEFINING ROOT STYLES      # Set root margin      \"root_margin\": \"1rem\",      # DEFINING SHAPES      # Base border radius in px      \"border_radius\": 8,      # DEFINING MUI COMPONENTS STYLES      # Matching input and button height in css size unit      \"input_button_height\": \"48px\",  }    # Default config loaded by app.py  default_config: Config = {      \"allow_unsafe_werkzeug\": False,      \"async_mode\": \"gevent\",      \"change_delay\": None,      \"chart_dark_template\": None,      \"base_url\": \"/\",      \"dark_mode\": True,      \"dark_theme\": None,      \"debug\": False,      \"extended_status\": False,      \"favicon\": None,      \"flask_log\": False,      \"host\": \"127.0.0.1\",      \"light_theme\": None,      \"margin\": \"1em\",      \"ngrok_token\": \"\",      \"notebook_proxy\": True,      \"notification_duration\": 3000,      \"propagate\": True,      \"run_browser\": True,      \"run_in_thread\": False,      \"run_server\": True,      \"server_config\": None,      \"single_client\": False,      \"system_notification\": False,      \"theme\": None,      \"time_zone\": None,      \"title\": None,      \"stylekit\": _default_stylekit.copy(),      \"upload_folder\": None,      \"use_arrow\": False,      \"use_reloader\": False,      \"watermark\": \"Taipy inside\",      \"webapp_path\": None,      \"port\": 5000,  } "}
{"text": "from __future__ import annotations    import typing as t    from ._page import _Page  from ._warnings import _warn  from .state import State    if t.TYPE_CHECKING:      from .page import Page      class Partial(_Page):      \"\"\"Re-usable Page content.        Partials are used when you need to use a partial page content in different      and not related pages. This allows not to have to repeat yourself when      creating your page templates.        Visual elements such as [`part`](../gui/viselements/part.md),      [`dialog`](../gui/viselements/dialog.md) or      [`pane`](../gui/viselements/pane.md) can use Partials.        Note that `Partial` has no constructor (no `__init__()` method): to create a      `Partial`, you must call the `Gui.add_partial()^` function.        Partials can be really handy if you want to modify a section of a page:      the `update_content()` method dynamically update pages that make use      of this `Partial` therefore making it easy to change the content of      any page, at any moment.      \"\"\"        _PARTIALS = \"__partials\"        __partials: t.Dict[str, Partial] = {}        def __init__(self, route: t.Optional[str] = None):          super().__init__()          if route is None:              self._route = f\"TaiPy_partials_{len(Partial.__partials)}\"              Partial.__partials[self._route] = self          else:              self._route = route        def update_content(self, state: State, content: str | \"Page\"):          \"\"\"Update partial content.            Arguments:              state (State^): The current user state as received in any callback.              content (str): The new content to use and display.          \"\"\"          if state and state._gui and callable(state._gui._update_partial):              state._gui._update_partial(self.__copy(content))          else:              _warn(\"'Partial.update_content()' must be called in the context of a callback.\")        def __copy(self, content: str | \"Page\") -> Partial:          new_partial = Partial(self._route)          from .page import Page            if isinstance(content, Page):              new_partial._renderer = content          else:              new_partial._renderer = type(self._renderer)(content=content) if self._renderer is not None else None          return new_partial "}
{"text": "from typing import Dict, Tuple    from taipy._cli._base_cli import _CLI      class _GuiCLI:      \"\"\"Command-line interface of GUI.\"\"\"        __GUI_ARGS: Dict[Tuple, Dict] = {          (\"--port\", \"-P\"): {              \"dest\": \"taipy_port\",              \"metavar\": \"PORT\",              \"nargs\": \"?\",              \"default\": \"\",              \"const\": \"\",              \"help\": \"Specify server port\",          },          (\"--host\", \"-H\"): {              \"dest\": \"taipy_host\",              \"metavar\": \"HOST\",              \"nargs\": \"?\",              \"default\": \"\",              \"const\": \"\",              \"help\": \"Specify server host\",          },          (\"--ngrok-token\",): {              \"dest\": \"taipy_ngrok_token\",              \"metavar\": \"NGROK_TOKEN\",              \"nargs\": \"?\",              \"default\": \"\",              \"const\": \"\",              \"help\": \"Specify NGROK Authtoken\",          },          (\"--webapp-path\",): {              \"dest\": \"taipy_webapp_path\",              \"metavar\": \"WEBAPP_PATH\",              \"nargs\": \"?\",              \"default\": \"\",              \"const\": \"\",              \"help\": \"The path to the web app to be used. The default is the webapp directory under gui in the Taipy GUI package directory.\",  # noqa: E501          },      }        __DEBUG_ARGS: Dict[str, Dict] = {          \"--debug\": {\"dest\": \"taipy_debug\", \"help\": \"Turn on debug\", \"action\": \"store_true\"},          \"--no-debug\": {\"dest\": \"taipy_no_debug\", \"help\": \"Turn off debug\", \"action\": \"store_true\"},      }        __RELOADER_ARGS: Dict[str, Dict] = {          \"--use-reloader\": {\"dest\": \"taipy_use_reloader\", \"help\": \"Auto reload on code changes\", \"action\": \"store_true\"},          \"--no-reloader\": {\"dest\": \"taipy_no_reloader\", \"help\": \"No reload on code changes\", \"action\": \"store_true\"},      }        @classmethod      def create_parser(cls):          gui_parser = _CLI._add_groupparser(\"Taipy GUI\", \"Optional arguments for Taipy GUI service\")            for args, arg_dict in cls.__GUI_ARGS.items():              taipy_arg = (args[0], cls.__add_taipy_prefix(args[0]), *args[1:])              gui_parser.add_argument(*taipy_arg, **arg_dict)            debug_group = gui_parser.add_mutually_exclusive_group()          for debug_arg, debug_arg_dict in cls.__DEBUG_ARGS.items():              debug_group.add_argument(debug_arg, cls.__add_taipy_prefix(debug_arg), **debug_arg_dict)            reloader_group = gui_parser.add_mutually_exclusive_group()          for reloader_arg, reloader_arg_dict in cls.__RELOADER_ARGS.items():              reloader_group.add_argument(reloader_arg, cls.__add_taipy_prefix(reloader_arg), **reloader_arg_dict)        @classmethod      def create_run_parser(cls):          run_parser = _CLI._add_subparser(\"run\", help=\"Run a Taipy application.\")          for args, arg_dict in cls.__GUI_ARGS.items():              run_parser.add_argument(*args, **arg_dict)            debug_group = run_parser.add_mutually_exclusive_group()          for debug_arg, debug_arg_dict in cls.__DEBUG_ARGS.items():              debug_group.add_argument(debug_arg, **debug_arg_dict)            reloader_group = run_parser.add_mutually_exclusive_group()          for reloader_arg, reloader_arg_dict in cls.__RELOADER_ARGS.items():              reloader_group.add_argument(reloader_arg, **reloader_arg_dict)        @classmethod      def parse_arguments(cls):          return _CLI._parse()        @classmethod      def __add_taipy_prefix(cls, key: str):          if key.startswith(\"--no-\"):              return key[:5] + \"taipy-\" + key[5:]            return key[:2] + \"taipy-\" + key[2:] "}
{"text": "from ..gui_types import PropertyType  from .library import Element, ElementLibrary, ElementProperty "}
{"text": "from __future__ import annotations    import typing as t      class _MapDict(object):      \"\"\"      Provide class binding, can utilize getattr, setattr functionality      Also perform update operation      \"\"\"        __local_vars = (\"_dict\", \"_update_var\")        def __init__(self, dict_import: dict, app_update_var=None):          self._dict = dict_import          # Bind app update var function          self._update_var = app_update_var        def __len__(self):          return self._dict.__len__()        def __length_hint__(self):          return self._dict.__length_hint__()        def __getitem__(self, key):          value = self._dict.__getitem__(key)          if isinstance(value, dict):              if self._update_var:                  return _MapDict(value, lambda s, v: self._update_var(f\"{key}.{s}\", v))              else:                  return _MapDict(value)          return value        def __setitem__(self, key, value):          if self._update_var:              self._update_var(key, value)          else:              self._dict.__setitem__(key, value)        def __delitem__(self, key):          self._dict.__delitem__(key)        def __missing__(self, key):          return self._dict.__missing__(key)        def __iter__(self):          return self._dict.__iter__()        def __reversed__(self):          return self._dict.__reversed__()        def __contains__(self, item):          return self._dict.__contains__(item)        # to be able to use getattr      def __getattr__(self, attr):          value = self._dict.__getitem__(attr)          if isinstance(value, dict):              if self._update_var:                  return _MapDict(value, lambda s, v: self._update_var(f\"{attr}.{s}\", v))              else:                  return _MapDict(value)          return value        def __setattr__(self, attr, value):          if attr in _MapDict.__local_vars:              super().__setattr__(attr, value)          else:              self.__setitem__(attr, value)        def keys(self):          return self._dict.keys()        def values(self):          return self._dict.values()        def items(self):          return self._dict.items()        def get(self, key: t.Any, default_value: t.Optional[str] = None) -> t.Optional[t.Any]:          return self._dict.get(key, default_value)        def clear(self) -> None:          self._dict.clear()        def setdefault(self, key, value=None) -> t.Optional[t.Any]:          return self._dict.setdefault(key, value)        def pop(self, key, default=None) -> t.Any:          return self._dict.pop(key, default)        def popitem(self) -> tuple:          return self._dict.popitem()        def copy(self) -> _MapDict:          return _MapDict(self._dict.copy(), self._update_var)        def update(self, d: dict) -> None:          current_keys = self.keys()          for k, v in d.items():              if k not in current_keys or self[k] != v:                  self.__setitem__(k, v) "}
{"text": "import re  import typing as t    _RE_MODULE = re.compile(r\"^__(.*?)__$\")      def _filter_locals(locals_dict: t.Dict[str, t.Any]) -> t.Dict[str, t.Any]:      return {k: v for k, v in locals_dict.items() if (not _RE_MODULE.match(k) or k == \"__name__\")} "}
{"text": "import typing as t    from .singleton import _Singleton    if t.TYPE_CHECKING:      from ..gui import Gui      class _RuntimeManager(object, metaclass=_Singleton):      def __init__(self):          self.__port_gui: t.Dict[int, \"Gui\"] = {}        def add_gui(self, gui: \"Gui\", port: int):          if port in self.__port_gui:              self.__port_gui[port].stop()          self.__port_gui[port] = gui        def get_used_port(self):          return list(self.__port_gui.keys()) "}
{"text": "import inspect  import sys  import typing as t  from types import FrameType, ModuleType      def _get_module_name_from_frame(frame: FrameType):      return frame.f_globals[\"__name__\"] if \"__name__\" in frame.f_globals else None      def _get_module_name_from_imported_var(var_name: str, value: t.Any, sub_module_name: str) -> str:      module_list = sys.modules.copy()      # the provided sub_module_name are expected to contain only part of the full module_name provided by sys.modules      # --> we can find potential matched modules based on the sub_module_name      potential_matched_module = [m for m in module_list.keys() if m.endswith(sub_module_name)]      for m in potential_matched_module:          module = module_list[m]          if hasattr(module, var_name) and getattr(module, var_name) is value:              return m      # failed fetching any matched module with variable and value      return sub_module_name "}
{"text": "import contextlib  import typing as t  import warnings  from threading import Thread  from urllib.parse import quote as urlquote  from urllib.parse import urlparse    from twisted.internet import reactor  from twisted.web.proxy import ProxyClient, ProxyClientFactory  from twisted.web.resource import Resource  from twisted.web.server import NOT_DONE_YET, Site    from .is_port_open import _is_port_open    # flake8: noqa: E402  from .singleton import _Singleton    warnings.filterwarnings(      \"ignore\",      category=UserWarning,      message=\"You do not have a working installation of the service_identity module: 'No module named 'service_identity''.*\",  # noqa: E501  )      if t.TYPE_CHECKING:      from ..gui import Gui      def _modifiedHandleResponseEnd(self):      if self._finished:          return      self._finished = True      with contextlib.suppress(Exception):          self.father.finish()      self.transport.loseConnection()      setattr(ProxyClient, \"handleResponseEnd\", _modifiedHandleResponseEnd)      class _TaipyReverseProxyResource(Resource):      proxyClientFactoryClass = ProxyClientFactory        def __init__(self, host, path, gui: \"Gui\", reactor=reactor):          Resource.__init__(self)          self.host = host          self.path = path          self.reactor = reactor          self._gui = gui        def getChild(self, path, request):          return _TaipyReverseProxyResource(              self.host,              self.path + b\"/\" + urlquote(path, safe=b\"\").encode(\"utf-8\"),              self._gui,              self.reactor,          )        def _get_port(self):          return self._gui._server._port        def render(self, request):          port = self._get_port()          host = self.host if port == 80 else \"%s:%d\" % (self.host, port)          request.requestHeaders.setRawHeaders(b\"host\", [host.encode(\"ascii\")])          request.content.seek(0, 0)          rest = self.path + b\"?\" + qs if (qs := urlparse(request.uri)[4]) else self.path          clientFactory = self.proxyClientFactoryClass(              request.method,              rest,              request.clientproto,              request.getAllHeaders(),              request.content.read(),              request,          )          self.reactor.connectTCP(self.host, port, clientFactory)          return NOT_DONE_YET      class NotebookProxy(object, metaclass=_Singleton):      def __init__(self, gui: \"Gui\", listening_port: int) -> None:          self._listening_port = listening_port          self._gui = gui          self._is_running = False        def run(self):          if self._is_running:              return          host = self._gui._get_config(\"host\", \"127.0.0.1\")          port = self._listening_port          if _is_port_open(host, port):              raise ConnectionError(                  f\"Port {port} is already opened on {host}. You have another server application running on the same port.\"  # noqa: E501              )          site = Site(_TaipyReverseProxyResource(host, b\"\", self._gui))          reactor.listenTCP(port, site)          Thread(target=reactor.run, args=(False,)).start()          self._is_running = True        def stop(self):          if not self._is_running:              return          self._is_running = False          reactor.stop() "}
{"text": "import typing as t  from operator import attrgetter    if t.TYPE_CHECKING:      from ..gui import Gui      def _getscopeattr(gui: \"Gui\", name: str, *more) -> t.Any:      if more:          return getattr(gui._get_data_scope(), name, more[0])      return getattr(gui._get_data_scope(), name)      def _getscopeattr_drill(gui: \"Gui\", name: str) -> t.Any:      return attrgetter(name)(gui._get_data_scope())      def _setscopeattr(gui: \"Gui\", name: str, value: t.Any):      if gui._is_broadcasting():          for scope in gui._get_all_data_scopes().values():              setattr(scope, name, value)      else:          setattr(gui._get_data_scope(), name, value)      def _setscopeattr_drill(gui: \"Gui\", name: str, value: t.Any):      if gui._is_broadcasting():          for scope in gui._get_all_data_scopes().values():              _attrsetter(scope, name, value)      else:          _attrsetter(gui._get_data_scope(), name, value)      def _hasscopeattr(gui: \"Gui\", name: str) -> bool:      return hasattr(gui._get_data_scope(), name)      def _delscopeattr(gui: \"Gui\", name: str):      delattr(gui._get_data_scope(), name)      def _attrsetter(obj: object, attr_str: str, value: object) -> None:      var_name_split = attr_str.split(sep=\".\")      for i in range(len(var_name_split) - 1):          sub_name = var_name_split[i]          obj = getattr(obj, sub_name)      setattr(obj, var_name_split[-1], value) "}
{"text": "import typing as t      def _get_css_var_value(value: t.Any) -> str:      if isinstance(value, str):          if \" \" in value:              return f'\"{value}\"'          return value      if isinstance(value, int):          return f\"{value}px\"      return f\"{value}\" "}
{"text": "import typing as t  from types import ModuleType    from ..page import Page      def _get_page_from_module(module: ModuleType) -> t.Optional[Page]:      return next((v for v in vars(module).values() if isinstance(v, Page)), None) "}
{"text": "from __future__ import annotations    import typing as t    if t.TYPE_CHECKING:      from ..gui import Gui      def _varname_from_content(gui: Gui, content: str) -> t.Optional[str]:      return next((k for k, v in gui._get_locals_bind().items() if isinstance(v, str) and v == content), None) "}
{"text": "from __future__ import annotations    import contextlib  import typing as t    from flask import g      class _LocalsContext:      __ctx_g_name = \"locals_context\"        def __init__(self) -> None:          self.__default_module: str = \"\"          self._lc_stack: t.List[str] = []          self._locals_map: t.Dict[str, t.Dict[str, t.Any]] = {}        def set_default(self, default: t.Dict[str, t.Any], default_module_name: str = \"\") -> None:          self.__default_module = default_module_name          self._locals_map[self.__default_module] = default        def get_default(self) -> t.Dict[str, t.Any]:          return self._locals_map[self.__default_module]        def get_all_keys(self) -> t.Set[str]:          keys = set()          for v in self._locals_map.values():              for i in v.keys():                  keys.add(i)          return keys        def get_all_context(self):          return self._locals_map.keys()        def add(self, context: t.Optional[str], locals_dict: t.Optional[t.Dict[str, t.Any]]):          if context is not None and locals_dict is not None and context not in self._locals_map:              self._locals_map[context] = locals_dict        @contextlib.contextmanager      def set_locals_context(self, context: t.Optional[str]) -> t.Iterator[None]:          try:              if context in self._locals_map:                  if hasattr(g, _LocalsContext.__ctx_g_name):                      self._lc_stack.append(getattr(g, _LocalsContext.__ctx_g_name))                  setattr(g, _LocalsContext.__ctx_g_name, context)              yield          finally:              if hasattr(g, _LocalsContext.__ctx_g_name):                  if len(self._lc_stack) > 0:                      setattr(g, _LocalsContext.__ctx_g_name, self._lc_stack.pop())                  else:                      delattr(g, _LocalsContext.__ctx_g_name)        def get_locals(self) -> t.Dict[str, t.Any]:          return self.get_default() if (context := self.get_context()) is None else self._locals_map[context]        def get_context(self) -> t.Optional[str]:          return getattr(g, _LocalsContext.__ctx_g_name) if hasattr(g, _LocalsContext.__ctx_g_name) else None        def is_default(self) -> bool:          return self.get_default() == self.get_locals()        def _get_locals_bind_from_context(self, context: t.Optional[str]):          if context is None:              context = self.__default_module          return self._locals_map[context] "}
{"text": "from ._attributes import (      _delscopeattr,      _getscopeattr,      _getscopeattr_drill,      _hasscopeattr,      _setscopeattr,      _setscopeattr_drill,  )  from ._locals_context import _LocalsContext  from ._map_dict import _MapDict  from ._runtime_manager import _RuntimeManager  from ._variable_directory import _variable_decode, _variable_encode, _VariableDirectory  from .boolean import _is_boolean, _is_boolean_true  from .clientvarname import _get_broadcast_var_name, _get_client_var_name, _to_camel_case  from .datatype import _get_data_type  from .date import _date_to_string, _string_to_date  from .expr_var_name import _get_expr_var_name  from .filename import _get_non_existent_file_path  from .filter_locals import _filter_locals  from .get_imported_var import _get_imported_var  from .get_module_name import _get_module_name_from_frame, _get_module_name_from_imported_var  from .get_page_from_module import _get_page_from_module  from .getdatecolstrname import _RE_PD_TYPE, _get_date_col_str_name  from .html import _get_css_var_value  from .is_debugging import is_debugging  from .is_port_open import _is_port_open  from .isnotebook import _is_in_notebook  from .types import (      _TaipyBase,      _TaipyBool,      _TaipyContent,      _TaipyContentHtml,      _TaipyContentImage,      _TaipyData,      _TaipyDate,      _TaipyDateRange,      _TaipyDict,      _TaipyLoNumbers,      _TaipyLov,      _TaipyLovValue,      _TaipyNumber,  )  from .varnamefromcontent import _varname_from_content "}
{"text": "import re  import typing as t    __expr_var_name_index: t.Dict[str, int] = {}  _RE_NOT_IN_VAR_NAME = r\"[^A-Za-z0-9]+\"      def _get_expr_var_name(expr: str) -> str:      var_name = re.sub(_RE_NOT_IN_VAR_NAME, \"_\", expr)      index = 0      if var_name in __expr_var_name_index.keys():          index = __expr_var_name_index[var_name]      __expr_var_name_index[var_name] = index + 1      return f\"tp_{var_name}_{index}\"      def _reset_expr_var_name():      __expr_var_name_index.clear() "}
{"text": "import socket      def _is_port_open(host, port) -> bool:      sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)      result = sock.connect_ex((host, port))      sock.close()      return result == 0 "}
{"text": "import json  import typing as t  from abc import ABC  from datetime import datetime    from .._warnings import _warn  from . import _date_to_string, _MapDict, _string_to_date, _variable_decode      class _TaipyBase(ABC):      __HOLDER_PREFIXES: t.Optional[t.List[str]] = None      _HOLDER_PREFIX = \"_Tp\"        def __init__(self, data: t.Any, hash_name: str) -> None:          self.__data = data          self.__hash_name = hash_name        def get(self):          return self.__data        def get_name(self):          return self.__hash_name        def set(self, data: t.Any):          self.__data = data        def cast_value(self, value: t.Any):          return value        def _get_readable_name(self):          try:              name, mod = _variable_decode(                  self.__hash_name[5:] if self.__hash_name.startswith(\"tpec_\") else self.__hash_name              )              return name if mod is None or mod == \"__main__\" else f\"{mod}.{name}\"          except BaseException:              return self.__hash_name        @staticmethod      def get_hash():          return NotImplementedError        @staticmethod      def _get_holder_prefixes() -> t.List[str]:          if _TaipyBase.__HOLDER_PREFIXES is None:              _TaipyBase.__HOLDER_PREFIXES = [cls.get_hash() + \"_\" for cls in _TaipyBase.__subclasses__()]          return _TaipyBase.__HOLDER_PREFIXES      class _TaipyData(_TaipyBase):      @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"D\"      class _TaipyBool(_TaipyBase):      def get(self):          return self.cast_value(super().get())        def cast_value(self, value: t.Any):          return bool(value)        @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"B\"      class _TaipyNumber(_TaipyBase):      def get(self):          try:              return float(super().get())          except Exception as e:              raise TypeError(f\"Variable '{self._get_readable_name()}' should hold a number: {e}\")        def cast_value(self, value: t.Any):          if isinstance(value, str):              try:                  return float(value) if value else 0.0              except Exception as e:                  _warn(f\"{self._get_readable_name()}: Parsing {value} as float\", e)                  return 0.0          return super().cast_value(value)        @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"N\"      class _TaipyLoNumbers(_TaipyBase):      def cast_value(self, value: t.Any):          if isinstance(value, str):              try:                  return list(map(lambda f: float(f), value[1:-1].split(\",\")))              except Exception as e:                  _warn(f\"{self._get_readable_name()}: Parsing {value} as an array of numbers\", e)                  return []          return super().cast_value(value)        @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"Ln\"      class _TaipyDate(_TaipyBase):      def get(self):          val = super().get()          if isinstance(val, datetime):              val = _date_to_string(val)          elif val is not None:              val = str(val)          return val        def cast_value(self, value: t.Any):          if isinstance(value, str):              return _string_to_date(value)          return super().cast_value(value)        @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"Dt\"      class _TaipyDateRange(_TaipyBase):      def get(self):          val = super().get()          if isinstance(val, list):              return [_date_to_string(v) if isinstance(v, datetime) else None if v is None else str(v) for v in val]          return val        def cast_value(self, value: t.Any):          if isinstance(value, list):              return [_string_to_date(v) if isinstance(v, str) else str(v) for v in value]          return super().cast_value(value)        @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"Dr\"      class _TaipyLovValue(_TaipyBase):      @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"Lv\"      class _TaipyLov(_TaipyBase):      @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"L\"      class _TaipyContent(_TaipyBase):      @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"C\"      class _TaipyContentImage(_TaipyBase):      @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"Ci\"      class _TaipyContentHtml(_TaipyBase):      @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"Ch\"      class _TaipyDict(_TaipyBase):      def get(self):          val = super().get()          return json.dumps(val._dict if isinstance(val, _MapDict) else val)        @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"Di\" "}
{"text": "import sys      def is_debugging() -> bool:      \"\"\"NOT DOCUMENTED\"\"\"      return hasattr(sys, \"gettrace\") and sys.gettrace() is not None "}
{"text": "import typing as t      def _is_boolean_true(s: t.Union[bool, str]) -> bool:      return (          s          if isinstance(s, bool)          else s.lower() in [\"true\", \"1\", \"t\", \"y\", \"yes\", \"yeah\", \"sure\"]          if isinstance(s, str)          else False      )      def _is_boolean(s: t.Any) -> bool:      if isinstance(s, bool):          return True      elif isinstance(s, str):          return s.lower() in [\"true\", \"1\", \"t\", \"y\", \"yes\", \"yeah\", \"sure\", \"false\", \"0\", \"f\", \"no\"]      else:          return False "}
{"text": "_replace_dict = {\".\": \"__\", \"[\": \"_SqrOp_\", \"]\": \"_SqrCl_\"}      def _get_client_var_name(var_name: str) -> str:      for k, v in _replace_dict.items():          var_name = var_name.replace(k, v)      return var_name      def _to_camel_case(value: str, upcase_first=False) -> str:      if not isinstance(value, str):          raise Exception(\"_to_camel_case allows only string parameter\")        if len(value) <= 1:          return value.lower()      value = value.replace(\"_\", \" \").title().replace(\" \", \"\").replace(\"[\", \"_\").replace(\"]\", \"_\")      return value[0].lower() + value[1:] if not upcase_first else value      def _get_broadcast_var_name(s: str) -> str:      return _get_client_var_name(f\"_bc_{s}\") "}
{"text": "import re  import typing as t    from .._warnings import _warn  from .boolean import _is_boolean, _is_boolean_true  from .clientvarname import _to_camel_case      def _get_column_desc(columns: t.Dict[str, t.Any], key: str) -> t.Optional[t.Dict[str, t.Any]]:      return next((x for x in columns.values() if x.get(\"dfid\") == key), None)      def _get_name_indexed_property(attributes: t.Dict[str, t.Any], name: str) -> t.Dict[str, t.Any]:      ret = {}      index_re = re.compile(name + r\"\\[(.*)\\]$\")      for key in attributes.keys():          if m := index_re.match(key):              ret[m.group(1)] = attributes.get(key)      return ret      def _update_col_desc_from_indexed(      attributes: t.Dict[str, t.Any], columns: t.Dict[str, t.Any], name: str, elt_name: str  ):      col_value = _get_name_indexed_property(attributes, name)      for k, v in col_value.items():          if col_desc := next((x for x in columns.values() if x.get(\"dfid\") == k), None):              if col_desc.get(_to_camel_case(name)) is None:                  col_desc[_to_camel_case(name)] = str(v)          else:              _warn(f\"{elt_name}: {name}[{k}] is not in the list of displayed columns.\")      def _enhance_columns(  # noqa: C901      attributes: t.Dict[str, t.Any], hash_names: t.Dict[str, str], columns: t.Dict[str, t.Any], elt_name: str  ):      _update_col_desc_from_indexed(attributes, columns, \"nan_value\", elt_name)      _update_col_desc_from_indexed(attributes, columns, \"width\", elt_name)      filters = _get_name_indexed_property(attributes, \"filter\")      for k, v in filters.items():          if _is_boolean_true(v):              if col_desc := _get_column_desc(columns, k):                  col_desc[\"filter\"] = True              else:                  _warn(f\"{elt_name}: filter[{k}] is not in the list of displayed columns.\")      editables = _get_name_indexed_property(attributes, \"editable\")      for k, v in editables.items():          if _is_boolean(v):              if col_desc := _get_column_desc(columns, k):                  col_desc[\"notEditable\"] = not _is_boolean_true(v)              else:                  _warn(f\"{elt_name}: editable[{k}] is not in the list of displayed columns.\")      group_by = _get_name_indexed_property(attributes, \"group_by\")      for k, v in group_by.items():          if _is_boolean_true(v):              if col_desc := _get_column_desc(columns, k):                  col_desc[\"groupBy\"] = True              else:                  _warn(f\"{elt_name}: group_by[{k}] is not in the list of displayed columns.\")      apply = _get_name_indexed_property(attributes, \"apply\")      for k, v in apply.items():  # pragma: no cover          if col_desc := _get_column_desc(columns, k):              if callable(v):                  value = hash_names.get(f\"apply[{k}]\")              elif isinstance(v, str):                  value = v.strip()              else:                  _warn(f\"{elt_name}: apply[{k}] should be a user or predefined function.\")                  value = None              if value:                  col_desc[\"apply\"] = value          else:              _warn(f\"{elt_name}: apply[{k}] is not in the list of displayed columns.\")      styles = _get_name_indexed_property(attributes, \"style\")      for k, v in styles.items():  # pragma: no cover          if col_desc := _get_column_desc(columns, k):              if callable(v):                  value = hash_names.get(f\"style[{k}]\")              elif isinstance(v, str):                  value = v.strip()              else:                  value = None              if value in columns.keys():                  _warn(f\"{elt_name}: style[{k}]={value} cannot be a column's name.\")              elif value:                  col_desc[\"style\"] = value          else:              _warn(f\"{elt_name}: style[{k}] is not in the list of displayed columns.\")      tooltips = _get_name_indexed_property(attributes, \"tooltip\")      for k, v in tooltips.items():  # pragma: no cover          if col_desc := _get_column_desc(columns, k):              if callable(v):                  value = hash_names.get(f\"tooltip[{k}]\")              elif isinstance(v, str):                  value = v.strip()              else:                  value = None              if value in columns.keys():                  _warn(f\"{elt_name}: tooltip[{k}]={value} cannot be a column's name.\")              elif value:                  col_desc[\"tooltip\"] = value          else:              _warn(f\"{elt_name}: tooltip[{k}] is not in the list of displayed columns.\")      return columns "}
{"text": "import typing as t  from datetime import datetime  from random import random    from ..data.data_scope import _DataScopes  from ._map_dict import _MapDict    if t.TYPE_CHECKING:      from ..gui import Gui      class _Bindings:      def __init__(self, gui: \"Gui\") -> None:          self.__gui = gui          self.__scopes = _DataScopes()        def _bind(self, name: str, value: t.Any) -> None:          if hasattr(self, name):              raise ValueError(f\"Variable '{name}' is already bound\")          if not name.isidentifier():              raise ValueError(f\"Variable name '{name}' is invalid\")          if isinstance(value, dict):              setattr(self._get_data_scope(), name, _MapDict(value))          else:              setattr(self._get_data_scope(), name, value)          # prop = property(self.__value_getter(name), self.__value_setter(name))          setattr(_Bindings, name, self.__get_property(name))        def __get_property(self, name):          def __setter(ud: _Bindings, value: t.Any):              if isinstance(value, dict):                  value = _MapDict(value, None)              ud.__gui._update_var(name, value)            def __getter(ud: _Bindings) -> t.Any:              value = getattr(ud._get_data_scope(), name)              if isinstance(value, _MapDict):                  return _MapDict(value._dict, lambda k, v: ud.__gui._update_var(f\"{name}.{k}\", v))              else:                  return value            return property(__getter, __setter)  # Getter, Setter        def _set_single_client(self, value: bool) -> None:          self.__scopes.set_single_client(value)        def _is_single_client(self) -> bool:          return self.__scopes.is_single_client()        def _get_or_create_scope(self, id: str):          create = not id          if create:              id = f\"{datetime.now().strftime('%Y%m%d%H%M%S%f')}-{random()}\"              self.__gui._send_ws_id(id)          self.__scopes.create_scope(id)          return id, create        def _new_scopes(self):          self.__scopes = _DataScopes()        def _get_data_scope(self):          return self.__scopes.get_scope(self.__gui._get_client_id())        def _get_all_scopes(self):          return self.__scopes.get_all_scopes() "}
{"text": "import re  import typing as t  from types import FrameType    from ._locals_context import _LocalsContext  from .get_imported_var import _get_imported_var  from .get_module_name import _get_module_name_from_frame, _get_module_name_from_imported_var      class _VariableDirectory:      def __init__(self, locals_context: _LocalsContext):          self._locals_context = locals_context          self._default_module = \"\"          self._var_dir: t.Dict[str, t.Dict] = {}          self._var_head: t.Dict[str, t.List[t.Tuple[str, str]]] = {}          self._imported_var_dir: t.Dict[str, t.List[t.Tuple[str, str, str]]] = {}        def set_default(self, frame: FrameType) -> None:          self._default_module = _get_module_name_from_frame(frame)          self.add_frame(frame)        def add_frame(self, frame: t.Optional[FrameType]) -> None:          if frame is None:              return          module_name = _get_module_name_from_frame(frame)          if module_name not in self._imported_var_dir:              imported_var_list = _get_imported_var(frame)              self._imported_var_dir[module_name] = imported_var_list        def pre_process_module_import_all(self) -> None:          for imported_dir in self._imported_var_dir.values():              additional_var_list: t.List[t.Tuple[str, str, str]] = []              for name, asname, module in imported_dir:                  if name != \"*\" or asname != \"*\":                      continue                  if module not in self._locals_context._locals_map.keys():                      continue                  with self._locals_context.set_locals_context(module):                      additional_var_list.extend(                          (v, v, module) for v in self._locals_context.get_locals().keys() if not v.startswith(\"_\")                      )              imported_dir.extend(additional_var_list)        def process_imported_var(self) -> None:          self.pre_process_module_import_all()          default_imported_dir = self._imported_var_dir[self._default_module]          with self._locals_context.set_locals_context(self._default_module):              for name, asname, module in default_imported_dir:                  if name == \"*\" and asname == \"*\":                      continue                  imported_module_name = _get_module_name_from_imported_var(                      name, self._locals_context.get_locals().get(asname, None), module                  )                  temp_var_name = self.add_var(asname, self._default_module)                  self.add_var(name, imported_module_name, temp_var_name)            for k, v in self._imported_var_dir.items():              with self._locals_context.set_locals_context(k):                  for name, asname, module in v:                      if name == \"*\" and asname == \"*\":                          continue                      imported_module_name = _get_module_name_from_imported_var(                          name, self._locals_context.get_locals().get(asname, None), module                      )                      var_name = self.get_var(name, imported_module_name)                      var_asname = self.get_var(asname, k)                      if var_name is None and var_asname is None:                          temp_var_name = self.add_var(asname, k)                          self.add_var(name, imported_module_name, temp_var_name)                      elif var_name is not None:                          self.add_var(asname, k, var_name)                      else:                          self.add_var(name, imported_module_name, var_asname)        def add_var(self, name: str, module: t.Optional[str], var_name: t.Optional[str] = None) -> str:          if module is None:              module = self._default_module          if gv := self.get_var(name, module):              return gv          var_encode = _variable_encode(name, module) if module != self._default_module else name          if var_name is None:              var_name = var_encode          self.__add_var_head(name, module, var_name)          if var_encode != var_name:              var_name_decode, module_decode = _variable_decode(var_name)              if module_decode is None:                  module_decode = self._default_module              self.__add_var_head(var_name_decode, module_decode, var_encode)          if name not in self._var_dir:              self._var_dir[name] = {module: var_name}          else:              self._var_dir[name][module] = var_name          return var_name        def __add_var_head(self, name: str, module: str, var_head: str) -> None:          if var_head not in self._var_head:              self._var_head[var_head] = [(name, module)]          else:              self._var_head[var_head].append((name, module))        def get_var(self, name: str, module: str) -> t.Optional[str]:          if name in self._var_dir and module in self._var_dir[name]:              return self._var_dir[name][module]          return None      _MODULE_NAME_MAP: t.List[str] = []  _MODULE_ID = \"_TPMDL_\"  _RE_TPMDL_DECODE = re.compile(r\"(.*?)\" + _MODULE_ID + r\"(\\d+)$\")      def _variable_encode(var_name: str, module_name: t.Optional[str]):      if module_name is None:          return var_name      if module_name not in _MODULE_NAME_MAP:          _MODULE_NAME_MAP.append(module_name)      return f\"{var_name}{_MODULE_ID}{_MODULE_NAME_MAP.index(module_name)}\"      def _variable_decode(var_name: str):      from ._evaluator import _Evaluator        if result := _RE_TPMDL_DECODE.match(var_name):          return _Evaluator._expr_decode(str(result[1])), _MODULE_NAME_MAP[int(result[2])]      return _Evaluator._expr_decode(var_name), None      def _reset_name_map():      _MODULE_NAME_MAP.clear() "}
{"text": "from typing import Dict      class _Singleton(type):      _instances: Dict = {}        def __call__(self, *args, **kwargs):          if self not in self._instances:              self._instances[self] = super(_Singleton, self).__call__(*args, **kwargs)          return self._instances[self] "}
{"text": "import re    import pandas as pd      def _get_data_type(value):      if pd.api.types.is_bool_dtype(value):          return \"bool\"      elif pd.api.types.is_integer_dtype(value):          return \"int\"      elif pd.api.types.is_float_dtype(value):          return \"float\"      return re.match(r\"^<class '(.*\\.)?(.*?)(\\d\\d)?'>\", str(type(value))).group(2) "}
{"text": "import ast  import inspect  import typing as t  from types import FrameType      def _get_imported_var(frame: FrameType) -> t.List[t.Tuple[str, str, str]]:      st = ast.parse(inspect.getsource(frame))      var_list: t.List[t.Tuple[str, str, str]] = []      for node in ast.walk(st):          if isinstance(node, ast.ImportFrom):              # get the imported element as (name, asname, module)              # ex: from module1 import a as x --> (\"a\", \"x\", \"module1\")              var_list.extend(                  (                      child_node.name,                      child_node.asname if child_node.asname is not None else child_node.name,                      node.module or \"\",                  )                  for child_node in node.names              )      return var_list "}
{"text": "import re  import typing as t  from datetime import date, datetime, time    from dateutil import parser  from pytz import utc    from .._warnings import _warn      def _date_to_string(date_val: t.Union[datetime, date, time]) -> str:      if isinstance(date_val, datetime):          # return date.isoformat() + 'Z', if possible          try:              return date_val.astimezone(utc).isoformat()          except Exception as e:              # astimezone() fails on Windows for pre-epoch times              # See https://bugs.python.org/issue36759              _warn(\"Exception raised converting date to ISO 8601\", e)      return date_val.isoformat()      def _string_to_date(date_str: str) -> t.Union[datetime, date]:      # return datetime.strptime(date_str, '%Y-%m-%dT%H:%M:%S.%fZ')      # return datetime.fromisoformat(date_str)      date = parser.parse(date_str)      date_regex = r\"^[A-Z][a-z]{2} (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \\d{2} \\d{4}$\"      return date.date() if re.match(date_regex, date_str) else date "}
{"text": "from importlib import util      def _is_in_notebook():  # pragma: no cover      try:          if not util.find_spec(\"IPython\"):              return False            from IPython import get_ipython            ipython = get_ipython()            if ipython is None or \"IPKernelApp\" not in ipython.config:              return False      except (ImportError, AttributeError):          return False      return True "}
{"text": "import typing as t  from pathlib import Path      def _get_non_existent_file_path(dir_path: Path, file_name: str) -> Path:      if not file_name:          file_name = \"taipy_file.bin\"      file_path = dir_path / file_name      index = 0      file_stem = file_path.stem      file_suffix = file_path.suffix      while file_path.exists():          file_path = dir_path / f\"{file_stem}.{index}{file_suffix}\"          index += 1      return file_path "}
{"text": "import re  import typing as t    _RE_PD_TYPE = re.compile(r\"^([^\\s\\d\\[]+)(\\d+)(\\[(.*,\\s(\\S+))\\])?\")      def _get_date_col_str_name(columns: t.List[str], col: str) -> str:      suffix = \"_str\"      while col + suffix in columns:          suffix += \"_\"      return col + suffix "}
{"text": "import typing as t    import numpy  import pandas as pd    from ..gui import Gui  from .data_format import _DataFormat  from .pandas_data_accessor import _PandasDataAccessor      class _NumpyDataAccessor(_PandasDataAccessor):      __types = (numpy.ndarray,)        @staticmethod      def get_supported_classes() -> t.List[str]:          return [t.__name__ for t in _NumpyDataAccessor.__types]  # type: ignore        def __get_dataframe(self, value: t.Any) -> pd.DataFrame:          return pd.DataFrame(value)        def get_col_types(self, var_name: str, value: t.Any) -> t.Union[None, t.Dict[str, str]]:  # type: ignore          if isinstance(value, _NumpyDataAccessor.__types):  # type: ignore              return super().get_col_types(var_name, self.__get_dataframe(value))          return None        def get_data(  # noqa: C901          self, guiApp: Gui, var_name: str, value: t.Any, payload: t.Dict[str, t.Any], data_format: _DataFormat      ) -> t.Dict[str, t.Any]:          if isinstance(value, _NumpyDataAccessor.__types):  # type: ignore              return super().get_data(guiApp, var_name, self.__get_dataframe(value), payload, data_format)          return {} "}
{"text": "import typing as t    import pandas as pd    from ..gui import Gui  from ..utils import _MapDict  from .data_format import _DataFormat  from .pandas_data_accessor import _PandasDataAccessor      class _ArrayDictDataAccessor(_PandasDataAccessor):      __types = (dict, list, tuple, _MapDict)        @staticmethod      def get_supported_classes() -> t.List[str]:          return [t.__name__ for t in _ArrayDictDataAccessor.__types]  # type: ignore        def __get_dataframe(self, value: t.Any) -> t.Union[t.List[pd.DataFrame], pd.DataFrame]:          if isinstance(value, list):              if not value or isinstance(value[0], (str, int, float, bool)):                  return pd.DataFrame({\"0\": value})              types = {type(x) for x in value}              if len(types) == 1:                  type_elt = next(iter(types), None)                  if type_elt == list:                      lengths = {len(x) for x in value}                      return (                          pd.DataFrame(value)                          if len(lengths) == 1                          else [pd.DataFrame({f\"{i}/0\": v}) for i, v in enumerate(value)]                      )                  elif type_elt == dict:                      return [pd.DataFrame(v) for v in value]                  elif type_elt == _MapDict:                      return [pd.DataFrame(v._dict) for v in value]                  elif type_elt == pd.DataFrame:                      return value                elif len(types) == 2 and list in types and pd.DataFrame in types:                  return [v if isinstance(v, pd.DataFrame) else pd.DataFrame({f\"{i}/0\": v}) for i, v in enumerate(value)]          elif isinstance(value, _MapDict):              return pd.DataFrame(value._dict)          return pd.DataFrame(value)        def get_col_types(self, var_name: str, value: t.Any) -> t.Union[None, t.Dict[str, str]]:  # type: ignore          if isinstance(value, _ArrayDictDataAccessor.__types):  # type: ignore              return super().get_col_types(var_name, self.__get_dataframe(value))          return None        def get_data(  # noqa: C901          self, guiApp: Gui, var_name: str, value: t.Any, payload: t.Dict[str, t.Any], data_format: _DataFormat      ) -> t.Dict[str, t.Any]:          if isinstance(value, _ArrayDictDataAccessor.__types):  # type: ignore              return super().get_data(guiApp, var_name, self.__get_dataframe(value), payload, data_format)          return {} "}
{"text": "from .data_accessor import _DataAccessor  from .decimator import LTTB, RDP, MinMaxDecimator, ScatterDecimator  from .utils import Decimator "}
{"text": "import inspect  import typing as t  from abc import ABC, abstractmethod    from .._warnings import _warn  from ..utils import _TaipyData  from .data_format import _DataFormat      class _DataAccessor(ABC):      _WS_DATE_FORMAT = \"%Y-%m-%dT%H:%M:%S.%fZ\"        @staticmethod      @abstractmethod      def get_supported_classes() -> t.List[str]:          pass        @abstractmethod      def get_data(          self, guiApp: t.Any, var_name: str, value: t.Any, payload: t.Dict[str, t.Any], data_format: _DataFormat      ) -> t.Dict[str, t.Any]:          pass        @abstractmethod      def get_col_types(self, var_name: str, value: t.Any) -> t.Dict[str, str]:          pass      class _InvalidDataAccessor(_DataAccessor):      @staticmethod      def get_supported_classes() -> t.List[str]:          return [type(None).__name__]        def get_data(          self, guiApp: t.Any, var_name: str, value: t.Any, payload: t.Dict[str, t.Any], data_format: _DataFormat      ) -> t.Dict[str, t.Any]:          return {}        def get_col_types(self, var_name: str, value: t.Any) -> t.Dict[str, str]:          return {}      class _DataAccessors(object):      def __init__(self) -> None:          self.__access_4_type: t.Dict[str, _DataAccessor] = {}            self.__invalid_data_accessor = _InvalidDataAccessor()            self.__data_format = _DataFormat.JSON            from .array_dict_data_accessor import _ArrayDictDataAccessor          from .numpy_data_accessor import _NumpyDataAccessor          from .pandas_data_accessor import _PandasDataAccessor            self._register(_PandasDataAccessor)          self._register(_ArrayDictDataAccessor)          self._register(_NumpyDataAccessor)        def _register(self, cls: t.Type[_DataAccessor]) -> None:          if not inspect.isclass(cls):              raise AttributeError(\"The argument of 'DataAccessors.register' should be a class\")          if not issubclass(cls, _DataAccessor):              raise TypeError(f\"Class {cls.__name__} is not a subclass of DataAccessor\")          names = cls.get_supported_classes()          if not names:              raise TypeError(f\"method {cls.__name__}.get_supported_classes returned an invalid value\")          # check existence          inst: t.Optional[_DataAccessor] = None          for name in names:              inst = self.__access_4_type.get(name)              if inst:                  break          if inst is None:              try:                  inst = cls()              except Exception as e:                  raise TypeError(f\"Class {cls.__name__} cannot be instanciated\") from e              if inst:                  for name in names:                      self.__access_4_type[name] = inst  # type: ignore        def __get_instance(self, value: _TaipyData) -> _DataAccessor:  # type: ignore          value = value.get()          access = self.__access_4_type.get(type(value).__name__)          if access is None:              _warn(f\"Can't find Data Accessor for type {type(value).__name__}.\")              return self.__invalid_data_accessor          return access        def _get_data(          self, guiApp: t.Any, var_name: str, value: _TaipyData, payload: t.Dict[str, t.Any]      ) -> t.Dict[str, t.Any]:          return self.__get_instance(value).get_data(guiApp, var_name, value.get(), payload, self.__data_format)        def _get_col_types(self, var_name: str, value: _TaipyData) -> t.Dict[str, str]:          return self.__get_instance(value).get_col_types(var_name, value.get())        def _set_data_format(self, data_format: _DataFormat):          self.__data_format = data_format "}
{"text": "from __future__ import annotations    import typing as t  from abc import ABC, abstractmethod    import numpy as np    from .._warnings import _warn    if t.TYPE_CHECKING:      import pandas as pd      class Decimator(ABC):      \"\"\"Base class for decimating chart data.        *Decimating* is the term used to name the process of reducing the number of      data points displayed in charts while retaining the overall shape of the traces.      `Decimator` is a base class that does decimation on data sets.        Taipy GUI comes out-of-the-box with several implementation of this class for      different use cases.      \"\"\"        _CHART_MODES: t.List[str] = []        def __init__(self, threshold: t.Optional[int], zoom: t.Optional[bool]) -> None:          \"\"\"Initialize a new `Decimator`.            Arguments:              threshold (Optional[int]): The minimum amount of data points before the                  decimator class is applied.              zoom (Optional[bool]): set to True to reapply the decimation                  when zoom or re-layout events are triggered.          \"\"\"          super().__init__()          self.threshold = threshold          self._zoom = zoom if zoom is not None else True        def _is_applicable(self, data: t.Any, nb_rows_max: int, chart_mode: str):          if chart_mode not in self._CHART_MODES:              _warn(f\"{type(self).__name__} is only applicable for {' '.join(self._CHART_MODES)}.\")              return False          if self.threshold is None:              if nb_rows_max < len(data):                  return True          elif self.threshold < len(data):              return True          return False        @abstractmethod      def decimate(self, data: np.ndarray, payload: t.Dict[str, t.Any]) -> np.ndarray:          \"\"\"Decimate function.            This method is executed when the appropriate conditions specified in the          constructor are met. This function implements the algorithm that determines          which data points are kept or dropped.            Arguments:              data (numpy.array): An array containing all the data points represented as                  tuples.              payload (Dict[str, any]): additional information on charts that is provided                  at runtime.            Returns:              An array of Boolean mask values. The array should set True or False for each                  of its indexes where True indicates that the corresponding data point                  from *data* should be preserved, or False requires that this                  data point be dropped.          \"\"\"          return NotImplementedError  # type: ignore      def _df_data_filter(      dataframe: pd.DataFrame,      x_column_name: t.Optional[str],      y_column_name: str,      z_column_name: str,      decimator: Decimator,      payload: t.Dict[str, t.Any],      is_copied: bool,  ):      df = dataframe.copy() if not is_copied else dataframe      if not x_column_name:          index = 0          while f\"tAiPy_index_{index}\" in df.columns:              index += 1          x_column_name = f\"tAiPy_index_{index}\"          df[x_column_name] = df.index      column_list = [x_column_name, y_column_name, z_column_name] if z_column_name else [x_column_name, y_column_name]      points = df[column_list].to_numpy()      mask = decimator.decimate(points, payload)      return df[mask], is_copied      def _df_relayout(      dataframe: pd.DataFrame,      x_column: t.Optional[str],      y_column: str,      chart_mode: str,      x0: t.Optional[float],      x1: t.Optional[float],      y0: t.Optional[float],      y1: t.Optional[float],      is_copied: bool,  ):      if chart_mode not in [\"lines+markers\", \"markers\"]:          return dataframe, is_copied      # if chart data is invalid      if x0 is None or x1 is None or y0 is None or y1 is None:          return dataframe, is_copied      df = dataframe.copy() if not is_copied else dataframe      is_copied = True      has_x_col = True        if not x_column:          index = 0          while f\"tAiPy_index_{index}\" in df.columns:              index += 1          x_column = f\"tAiPy_index_{index}\"          df[x_column] = df.index          has_x_col = False        # if chart_mode is empty      if chart_mode == \"lines+markers\":          # only filter by x column          df = df.loc[(df[x_column] > x0) & (df[x_column] < x1)]      else:          # filter by both x and y columns          df = df.loc[(df[x_column] > x0) & (df[x_column] < x1) & (df[y_column] > y0) & (df[y_column] < y1)]  # noqa      if not has_x_col:          df.drop(x_column, axis=1, inplace=True)      return df, is_copied "}
{"text": "from enum import Enum      class _DataFormat(Enum):      JSON = \"JSON\"      APACHE_ARROW = \"ARROW\" "}
{"text": "import base64  import pathlib  import tempfile  import typing as t  import urllib.parse  from importlib import util  from pathlib import Path  from sys import getsizeof    from .._warnings import _warn  from ..utils import _get_non_existent_file_path, _variable_decode    _has_magic_module = False    if util.find_spec(\"magic\"):      import magic        _has_magic_module = True      class _ContentAccessor:      def __init__(self, data_url_max_size: int) -> None:          self.__content_paths: t.Dict[str, pathlib.Path] = {}          self.__url_is_image: t.Dict[str, bool] = {}          self.__paths: t.Dict[pathlib.Path, str] = {}          self.__data_url_max_size = data_url_max_size          self.__temp_dir_path = Path(tempfile.gettempdir())        def get_path(self, path: pathlib.Path) -> str:          url_path = self.__paths.get(path)          if url_path is None:              self.__paths[path] = url_path = \"taipyStatic\" + str(len(self.__paths))          return url_path        def get_content_path(          self, url_path: str, file_name: str, bypass: t.Optional[str]      ) -> t.Tuple[t.Union[pathlib.Path, None], bool]:          content_path = self.__content_paths.get(url_path)          if not content_path:              return (None, True)          return (content_path, bypass is not None or self.__url_is_image.get(f\"{url_path}/{file_name}\", False))        def __get_mime_from_file(self, path: pathlib.Path):          if _has_magic_module:              try:                  return magic.from_file(str(path), mime=True)              except Exception as e:                  _warn(f\"Exception reading mime type in '{path}'\", e)          return None        def __get_display_name(self, var_name: str) -> str:          if not isinstance(var_name, str):              return var_name          if var_name.startswith(\"_tpC_\"):              var_name = var_name[5:]          if var_name.startswith(\"tpec_\"):              var_name = var_name[5:]          return _variable_decode(var_name)[0]        def get_info(self, var_name: str, value: t.Any, image: bool) -> t.Union[str, t.Tuple[str], t.Any]:  # noqa: C901          if value is None:              return \"\"          newvalue = value          mime = None          if not isinstance(newvalue, (str, pathlib.Path)) and (              getsizeof(newvalue) > self.__data_url_max_size or not _has_magic_module          ):              # write data to file              file_name = \"TaiPyContent.bin\"              if _has_magic_module:                  try:                      mime = magic.from_buffer(value, mime=True)                      file_name = \"TaiPyContent.\" + mime.split(\"/\")[-1]                  except Exception as e:                      _warn(f\"{self.__get_display_name(var_name)} ({type(value)}) cannot be typed\", e)              file_path = _get_non_existent_file_path(self.__temp_dir_path, file_name)              try:                  with open(file_path, \"wb\") as temp_file:                      temp_file.write(value)              except Exception as e:                  _warn(f\"{self.__get_display_name(var_name)} ({type(value)}) cannot be written to file {file_path}\", e)              newvalue = file_path          if isinstance(newvalue, (str, pathlib.Path)):              path = pathlib.Path(newvalue) if isinstance(newvalue, str) else newvalue              if not path.is_file():                  if (                      var_name != \"Gui.download\"                      and not str(path).startswith(\"http\")                      and not str(path).startswith(\"/\")                      and not str(path).strip().lower().startswith(\"<svg\")                  ):                      _warn(f\"{self.__get_display_name(var_name)}: file '{value}' does not exist.\")                  return str(value)              if image:                  if not mime:                      mime = self.__get_mime_from_file(path)                  if mime and not mime.startswith(\"image\"):                      _warn(f\"{self.__get_display_name(var_name)}: file '{path}' mime type ({mime}) is not an image.\")                      return f\"Invalid content: {mime}\"              dir_path = path.resolve().parent              url_path = self.get_path(dir_path)              self.__content_paths[url_path] = dir_path              file_url = f\"{url_path}/{path.name}\"              self.__url_is_image[file_url] = image              return (urllib.parse.quote_plus(file_url, safe=\"/\"),)          elif _has_magic_module:              try:                  mime = magic.from_buffer(value, mime=True)                  if not image or mime.startswith(\"image\"):                      return f\"data:{mime};base64,\" + str(base64.b64encode(value), \"utf-8\")                  _warn(f\"{self.__get_display_name(var_name)}: ({type(value)}) does not have an image mime type: {mime}.\")                  return f\"Invalid content: {mime}\"              except Exception as e:                  _warn(f\"{self.__get_display_name(var_name)}: ({type(value)}) cannot be base64 encoded\", e)                  return \"Cannot be base64 encoded\"          else:              _warn(                  \"python-magic (and python-magic-bin on Windows) packages need to be installed if you want to process content as an array of bytes.\"  # noqa: E501              )              return \"Cannot guess content type\" "}
{"text": "from __future__ import annotations    import typing as t  from types import SimpleNamespace    from .._warnings import _warn      class _DataScopes:      _GLOBAL_ID = \"global\"        def __init__(self) -> None:          self.__scopes: t.Dict[str, SimpleNamespace] = {_DataScopes._GLOBAL_ID: SimpleNamespace()}          self.__single_client = True        def set_single_client(self, value: bool) -> None:          self.__single_client = value        def is_single_client(self) -> bool:          return self.__single_client        def get_scope(self, client_id: t.Optional[str]) -> SimpleNamespace:          if self.__single_client:              return self.__scopes[_DataScopes._GLOBAL_ID]          # global context in case request is not registered or client_id is not          # available (such as in the context of running tests)          if not client_id:              _warn(\"Empty session id, using global scope instead.\")              return self.__scopes[_DataScopes._GLOBAL_ID]          if client_id not in self.__scopes:              _warn(                  f\"Session id {client_id} not found in data scope. Taipy will automatically create a scope for this session id but you may have to reload your page.\"  # noqa: E501              )              self.create_scope(client_id)          return self.__scopes[client_id]        def get_all_scopes(self) -> t.Dict[str, SimpleNamespace]:          return self.__scopes        def create_scope(self, id: str) -> None:          if self.__single_client:              return          if id is None:              _warn(\"Empty session id, might be due to unestablished WebSocket connection.\")              return          if id not in self.__scopes:              self.__scopes[id] = SimpleNamespace()        def delete_scope(self, id: str) -> None:  # pragma: no cover          if self.__single_client:              return          if id is None:              _warn(\"Empty session id, might be due to unestablished WebSocket connection.\")              return          if id in self.__scopes:              del self.__scopes[id] "}
{"text": "import typing as t    import numpy as np    from ..utils import Decimator      class ScatterDecimator(Decimator):      \"\"\"A decimator designed for scatter charts.        This algorithm fits the data points into a grid. If multiple points are in the same grid      cell, depending on the chart configuration, some points are removed to reduce the number      points being displayed.        This class can only be used with scatter charts.      \"\"\"        _CHART_MODES = [\"markers\"]        def __init__(          self,          binning_ratio: t.Optional[float] = None,          max_overlap_points: t.Optional[int] = None,          threshold: t.Optional[int] = None,          zoom: t.Optional[bool] = True,      ):          \"\"\"Initialize a new `ScatterDecimator`.            Arguments:              binning_ratio (Optional[float]): the size of the data grid for the algorithm.                  The higher the value, the smaller the grid size.              max_overlap_points (Optional(int)): the maximum number of points for a single cell                  within the data grid within the algorithm. This dictates how dense a single                  grid cell can be.              threshold (Optional[int]): The minimum amount of data points before the                  decimation is applied.              zoom (Optional[bool]): set to True to reapply the decimation                  when zoom or re-layout events are triggered.          \"\"\"          super().__init__(threshold, zoom)          binning_ratio = binning_ratio if binning_ratio is not None else 1          self._binning_ratio = binning_ratio if binning_ratio > 0 else 1          self._max_overlap_points = max_overlap_points if max_overlap_points is not None else 3        def decimate(self, data: np.ndarray, payload: t.Dict[str, t.Any]) -> np.ndarray:          n_rows = data.shape[0]          mask = np.empty(n_rows, dtype=bool)          width = payload.get(\"width\", None)          height = payload.get(\"height\", None)          if width is None or height is None:              mask.fill(True)              return mask          mask.fill(False)          grid_x, grid_y = round(width / self._binning_ratio), round(height / self._binning_ratio)          x_col, y_col = data[:, 0], data[:, 1]          min_x, max_x = np.amin(x_col), np.amax(x_col)          min_y, max_y = np.amin(y_col), np.amax(y_col)          min_max_x_diff, min_max_y_diff = max_x - min_x, max_y - min_y          x_grid_map = np.rint((x_col - min_x) * grid_x / min_max_x_diff).astype(int)          y_grid_map = np.rint((y_col - min_y) * grid_y / min_max_y_diff).astype(int)          z_grid_map = None          grid_shape = (grid_x + 1, grid_y + 1)          if len(data[0]) == 3:              grid_z = grid_x              grid_shape = (grid_x + 1, grid_y + 1, grid_z + 1)  # type: ignore              z_col = data[:, 2]              min_z, max_z = np.amin(z_col), np.amax(z_col)              min_max_z_diff = max_z - min_z              z_grid_map = np.rint((z_col - min_z) * grid_z / min_max_z_diff).astype(int)          grid = np.empty(grid_shape, dtype=int)          grid.fill(0)          if z_grid_map is not None:              for i in np.arange(n_rows):                  if grid[x_grid_map[i], y_grid_map[i], z_grid_map[i]] < self._max_overlap_points:                      grid[x_grid_map[i], y_grid_map[i], z_grid_map[i]] += 1                      mask[i] = True          else:              for i in np.arange(n_rows):                  if grid[x_grid_map[i], y_grid_map[i]] < self._max_overlap_points:                      grid[x_grid_map[i], y_grid_map[i]] += 1                      mask[i] = True          return mask "}
{"text": "from .lttb import LTTB  from .minmax import MinMaxDecimator  from .rdp import RDP  from .scatter_decimator import ScatterDecimator "}
{"text": "import typing as t    import numpy as np    from ..utils import Decimator      class MinMaxDecimator(Decimator):      \"\"\"A decimator using the MinMax algorithm.        The MinMax algorithm is an efficient algorithm that preserves the peaks within the data. It      can work very well with noisy signal data where data peeks need to be highlighted.        This class can only be used with line charts.      \"\"\"        _CHART_MODES = [\"lines+markers\"]        def __init__(self, n_out: int, threshold: t.Optional[int] = None, zoom: t.Optional[bool] = True):          \"\"\"Initialize a new `MinMaxDecimator`.            Arguments:              n_out (int): The maximum number of points that will be displayed after decimation.              threshold (Optional[int]): The minimum amount of data points before the                  decimation is applied.              zoom (Optional[bool]): set to True to reapply the decimation                  when zoom or re-layout events are triggered.          \"\"\"          super().__init__(threshold, zoom)          self._n_out = n_out // 2        def decimate(self, data: np.ndarray, payload: t.Dict[str, t.Any]) -> np.ndarray:          if self._n_out >= data.shape[0]:              return np.full(len(data), False)          # Create a boolean mask          x = data[:, 0]          y = data[:, 1]          num_bins = self._n_out          pts_per_bin = x.size // num_bins          # Create temp to hold the reshaped & slightly cropped y          y_temp = y[: num_bins * pts_per_bin].reshape((num_bins, pts_per_bin))          # use argmax/min to get column locations          cc_max = np.argmax(y_temp, axis=1)          cc_min = np.argmin(y_temp, axis=1)          rr = np.arange(0, num_bins)          # compute the flat index to where these are          flat_max = cc_max + rr * pts_per_bin          flat_min = cc_min + rr * pts_per_bin          mm_mask = np.full((x.size,), False)          mm_mask[flat_max] = True          mm_mask[flat_min] = True          return mm_mask "}
{"text": "import typing as t    import numpy as np    from ..utils import Decimator      class LTTB(Decimator):      \"\"\"A decimator using the LTTB algorithm.        The LTTB algorithm is an high performance algorithm that significantly reduces the number of      data points. It can work very well with time-series data to show trends using by using only      a few data points.        This class can only be used with line charts.      \"\"\"        _CHART_MODES = [\"lines+markers\"]        def __init__(self, n_out: int, threshold: t.Optional[int] = None, zoom: t.Optional[bool] = True) -> None:          \"\"\"Initialize a new `LTTB`.            Arguments:              n_out (int): The maximum number of points that will be displayed after decimation.              threshold (Optional[int]): The minimum amount of data points before the                  decimation is applied.              zoom (Optional[bool]): set to True to reapply the decimation                  when zoom or re-layout events are triggered.          \"\"\"          super().__init__(threshold, zoom)          self._n_out = n_out        @staticmethod      def _areas_of_triangles(a, bs, c):          bs_minus_a = bs - a          a_minus_bs = a - bs          return 0.5 * abs((a[0] - c[0]) * (bs_minus_a[:, 1]) - (a_minus_bs[:, 0]) * (c[1] - a[1]))        def decimate(self, data: np.ndarray, payload: t.Dict[str, t.Any]) -> np.ndarray:          n_out = self._n_out          if n_out >= data.shape[0]:              return np.full(len(data), True)            if n_out < 3:              raise ValueError(\"Can only down-sample to a minimum of 3 points\")            # Split data into bins          n_bins = n_out - 2          data_bins = np.array_split(data[1:-1], n_bins)            prev_a = data[0]          start_pos = 0            # Prepare output mask array          # First and last points are the same as in the input.          out_mask = np.full(len(data), False)          out_mask[0] = True          out_mask[len(data) - 1] = True            # Largest Triangle Three Buckets (LTTB):          # In each bin, find the point that makes the largest triangle          # with the point saved in the previous bin          # and the centroid of the points in the next bin.          for i in range(len(data_bins)):              this_bin = data_bins[i]              next_bin = data_bins[i + 1] if i < n_bins - 1 else data[-1:]              a = prev_a              bs = this_bin              c = next_bin.mean(axis=0)                areas = LTTB._areas_of_triangles(a, bs, c)              bs_pos = np.argmax(areas)              prev_a = bs[bs_pos]              out_mask[start_pos + bs_pos] = True              start_pos += len(this_bin)            return out_mask "}
{"text": "import typing as t    import numpy as np    from ..utils import Decimator      class RDP(Decimator):      \"\"\"A decimator using the RDP algorithm.        The RDP algorithm reduces a shape made of line segments into a similar shape with      less points. This algorithm should be used if the final visual representation is      prioritized over the performance of the application.        This class can only be used with line charts.      \"\"\"        _CHART_MODES = [\"lines+markers\"]        def __init__(          self,          epsilon: t.Optional[int] = None,          n_out: t.Optional[int] = None,          threshold: t.Optional[int] = None,          zoom: t.Optional[bool] = True,      ):          \"\"\"Initialize a new `RDP`.            Arguments:              epsilon (Optional[int]): The epsilon value for the RDP algorithm. If this value                  is being used, the *n_out* argument is ignored.              n_out (Optional(int)): The maximum number of points that are displayed after                  decimation. This value is ignored if the epsilon value is used.<br/>                  This process is not very efficient so consider using `LTTB` or `MinMaxDecimator`                  if the provided data has more than 100.000 data points.              threshold (Optional[int]): The minimum amount of data points before the                  decimation is applied.              zoom (Optional[bool]): set to True to reapply the decimation                  when zoom or re-layout events are triggered.          \"\"\"          super().__init__(threshold, zoom)          self._epsilon = epsilon          self._n_out = n_out        @staticmethod      def dsquared_line_points(P1, P2, points):          \"\"\"          Calculate only squared distance, only needed for comparison          \"\"\"          xdiff = P2[0] - P1[0]          ydiff = P2[1] - P1[1]          nom = (ydiff * points[:, 0] - xdiff * points[:, 1] + P2[0] * P1[1] - P2[1] * P1[0]) ** 2          denom = ydiff ** 2 + xdiff ** 2          return np.divide(nom, denom)        @staticmethod      def __rdp_epsilon(data, epsilon: int):          # initiate mask array          # same amount of points          mask = np.empty(data.shape[0], dtype=bool)            # Assume all points are valid and falsify those which are found          mask.fill(True)            # The stack to select start and end index          stack: t.List[t.Tuple[int, int]] = [(0, data.shape[0] - 1)]  # type: ignore            while stack:              # Pop the last item              (start, end) = stack.pop()                # nothing to calculate if no points in between              if end - start <= 1:                  continue                # Calculate distance to points              P1 = data[start]              P2 = data[end]              points = data[start + 1 : end]              dsq = RDP.dsquared_line_points(P1, P2, points)                mask_eps = dsq > epsilon ** 2                if mask_eps.any():                  # max point outside eps                  # Include index that was sliced out                  # Also include the start index to get absolute index                  # And not relative                  mid = np.argmax(dsq) + 1 + start                  stack.append((start, mid))  # type: ignore                  stack.append((mid, end))  # type: ignore                else:                  # Points in between are redundant                  mask[start + 1 : end] = False            return mask        @staticmethod      def __rdp_points(M, n_out):          M_len = M.shape[0]            if M_len <= n_out:              mask = np.empty(M_len, dtype=bool)              mask.fill(True)              return mask            weights = np.empty(M_len)          # weights.fill(0)          weights[0] = float(\"inf\")          weights[M_len - 1] = float(\"inf\")            stack = [(0, M_len - 1)]            while stack:              (start, end) = stack.pop()              if end - start <= 1:                  continue              dsq = RDP.dsquared_line_points(M[start], M[end], M[start + 1 : end])              max_dist_index = np.argmax(dsq) + start + 1              weights[max_dist_index] = np.amax(dsq)              stack.append((start, max_dist_index))              stack.append((max_dist_index, end))            maxTolerance = np.sort(weights)[M_len - n_out]            return weights >= maxTolerance        def decimate(self, data: np.ndarray, payload: t.Dict[str, t.Any]) -> np.ndarray:          if self._epsilon:              return RDP.__rdp_epsilon(data, self._epsilon)          elif self._n_out:              return RDP.__rdp_points(data, self._n_out)          raise RuntimeError(\"RDP Decimator failed to run. Fill in either 'epsilon' or 'n_out' value\") "}
{"text": "import typing as t    from ..utils.singleton import _Singleton    if t.TYPE_CHECKING:      from ._element import _Block      class _BuilderContextManager(object, metaclass=_Singleton):      def __init__(self):          self.__blocks: t.List[\"_Block\"] = []        def push(self, element: \"_Block\") -> None:          self.__blocks.append(element)        def pop(self) -> t.Optional[\"_Block\"]:          return self.__blocks.pop() if self.__blocks else None        def peek(self) -> t.Optional[\"_Block\"]:          return self.__blocks[-1] if self.__blocks else None "}
{"text": "from ._api_generator import _ElementApiGenerator  from ._element import html    # separate import for \"Page\" class so stubgen can properly generate pyi file  from .page import Page    _ElementApiGenerator().add_default() "}
{"text": "import typing as t    from .._renderers import _Renderer  from ._context_manager import _BuilderContextManager  from ._element import _Block, _DefaultBlock, _Element      class Page(_Renderer):      \"\"\"Page generator for the Builder API.        This class is used to create a page created with the Builder API.<br/>      Instance of this class can be added to the application using `Gui.add_page()^`.        This class is typically be used as a Python Context Manager to add the elements.<br/>      Here is how you can create a single-page application, creating the elements with code:      ```py      from taipy.gui import Gui      from taipy.gui.builder import Page, button        def do_something(state):          pass        with Page() as page:          button(label=\"Press me\", on_action=do_something)        Gui(page).run()      ```      \"\"\"        def __init__(self, element: t.Optional[_Element] = None, **kwargs) -> None:          \"\"\"Initialize a new page.            Arguments:              element (*Element*): An optional element, defined in the `taipy.gui.builder` module,                  that is created in the page.<br/>                  The default creates a `part` where several elements can be stored.          \"\"\"          if element is None:              element = _DefaultBlock()          kwargs[\"content\"] = element          super().__init__(**kwargs)        # Generate JSX from Element Object      def render(self, gui) -> str:          if self._base_element is None:              return \"<h1>No Base Element found for Page</h1>\"          return self._base_element._render(gui)        def add(self, *elements: _Element):          if not isinstance(self._base_element, _Block):              raise RuntimeError(\"Can't add child element to non-block element\")          for element in elements:              if element not in self._base_element._children:                  self._base_element._children.append(element)          return self        def __enter__(self):          if self._base_element is None:              raise RuntimeError(\"Can't use context manager with missing block element for Page\")          if not isinstance(self._base_element, _Block):              raise RuntimeError(\"Can't add child element to non-block element\")          _BuilderContextManager().push(self._base_element)          return self        def __exit__(self, exc_type, exc_value, traceback):          _BuilderContextManager().pop() "}
{"text": "import typing as t    from .._renderers.factory import _Factory      class _BuilderFactory(_Factory):      @staticmethod      def create_element(gui, element_type: str, properties: t.Dict[str, t.Any]) -> t.Tuple[str, str]:          builder_html = _Factory.call_builder(gui, element_type, properties, True)          if builder_html is None:              return f\"<div>INVALID SYNTAX - Element is '{element_type}'\", \"div\"          return builder_html  # type: ignore "}
{"text": "from __future__ import annotations    import copy  import typing as t  from abc import ABC, abstractmethod  from collections.abc import Iterable    from ._context_manager import _BuilderContextManager  from ._factory import _BuilderFactory    if t.TYPE_CHECKING:      from ..gui import Gui      class _Element(ABC):      \"\"\"NOT DOCUMENTED\"\"\"        _ELEMENT_NAME = \"\"      _DEFAULT_PROPERTY = \"\"        def __new__(cls, *args, **kwargs):          obj = super(_Element, cls).__new__(cls)          parent = _BuilderContextManager().peek()          if parent is not None:              parent.add(obj)          return obj        def __init__(self, *args, **kwargs):          self._properties: t.Dict[str, t.Any] = {}          if args and self._DEFAULT_PROPERTY != \"\":              self._properties = {self._DEFAULT_PROPERTY: args[0]}          self._properties.update(kwargs)          self.parse_properties()        def update(self, **kwargs):          self._properties.update(kwargs)          self.parse_properties()        # Convert property value to string      def parse_properties(self):          self._properties = {k: _Element._parse_property(v) for k, v in self._properties.items()}        # Get a deepcopy version of the properties      def _deepcopy_properties(self):          return copy.deepcopy(self._properties)        @staticmethod      def _parse_property(value: t.Any) -> t.Any:          if isinstance(value, (str, dict, Iterable)):              return value          if hasattr(value, \"__name__\"):              return str(getattr(value, \"__name__\"))          return str(value)        @abstractmethod      def _render(self, gui: \"Gui\") -> str:          pass      class _Block(_Element):      \"\"\"NOT DOCUMENTED\"\"\"        def __init__(self, *args, **kwargs):          super().__init__(*args, **kwargs)          self._children: t.List[_Element] = []        def add(self, *elements: _Element):          for element in elements:              if element not in self._children:                  self._children.append(element)          return self        def __enter__(self):          _BuilderContextManager().push(self)          return self        def __exit__(self, exc_type, exc_value, traceback):          _BuilderContextManager().pop()        def _render(self, gui: \"Gui\") -> str:          el = _BuilderFactory.create_element(gui, self._ELEMENT_NAME, self._deepcopy_properties())          return f\"{el[0]}{self._render_children(gui)}</{el[1]}>\"        def _render_children(self, gui: \"Gui\") -> str:          return \"\\n\".join([child._render(gui) for child in self._children])      class _DefaultBlock(_Block):      _ELEMENT_NAME = \"part\"        def __init__(self, *args, **kwargs):          super().__init__(*args, **kwargs)      class html(_Block):      \"\"\"A visual element defined as an HTML tag.        Use this class to integrate raw HTML to your page.        This element can be used as a block element.      \"\"\"        def __init__(self, *args, **kwargs):          \"\"\"Create a new `html` block.            Arguments:              args (any[]): A list of one or two unnamed arguments:                    - *args[0]* is the HTML tag name. If empty or None, this represents an HTML text                    node.                  - *args[1]* (optional) is the text of this element.<br/>                    Note that special HTML characters (such as '&lt;' or '&amp;') do not need to be protected.              kwargs (dict[str, any]): the HTML attributes for this element.<br/>                  These should be valid attribute names, with valid attribute values.            Examples:              - To generate `<br/>`, use:                 ```                 html(\"br\")                 ```              - To generate `<h1>My page title</h1>`, use:                 ```                 html(\"h1\", \"My page title\")                 ```              - To generate `<h1 id=\"page-title\">My page title</h1>`, use:                 ```                 html(\"h1\", \"My page title\", id=\"page-title\")                 ```              - To generate `<p>This is a <b>Taipy GUI</b> element.</p>`, use:                 ```                 with html(\"p\"):                     html(None, \"This is a \")                     html(\"b\", \"Taipy GUI\")                     html(None, \" element.\")                 ```          \"\"\"          super().__init__(*args, **kwargs)          if not args:              raise RuntimeError(\"Can't render html element. Missing html tag name.\")          self._ELEMENT_NAME = args[0] if args[0] else None          self._content = args[1] if len(args) > 1 else \"\"        def _render(self, gui: \"Gui\") -> str:          if self._ELEMENT_NAME:              attrs = \"\"              if self._properties:                  attrs = \" \" + \" \".join([f'{k}=\"{str(v)}\"' for k, v in self._properties.items()])              return f\"<{self._ELEMENT_NAME}{attrs}>{self._content}{self._render_children(gui)}</{self._ELEMENT_NAME}>\"          else:              return self._content      class _Control(_Element):      \"\"\"NOT DOCUMENTED\"\"\"        def __init__(self, *args, **kwargs):          super().__init__(*args, **kwargs)        def _render(self, gui: \"Gui\") -> str:          el = _BuilderFactory.create_element(gui, self._ELEMENT_NAME, self._deepcopy_properties())          return (              f\"<div>{el[0]}</{el[1]}></div>\"              if f\"<{el[1]}\" in el[0] and f\"</{el[1]}\" not in el[0]              else f\"<div>{el[0]}</div>\"          )        def __enter__(self):          raise RuntimeError(f\"Can't use Context Manager for control type '{self._ELEMENT_NAME}'\")        def __exit__(self, exc_type, exc_value, traceback):          raise RuntimeError(f\"Can't use Context Manager for control type '{self._ELEMENT_NAME}'\") "}
{"text": "import inspect  import json  import os  import sys  import types  import typing as t    from taipy.logger._taipy_logger import _TaipyLogger    from ..utils.singleton import _Singleton  from ._element import _Block, _Control    if t.TYPE_CHECKING:      from ..extension.library import ElementLibrary      class _ElementApiGenerator(object, metaclass=_Singleton):      def __init__(self):          self.__module: t.Optional[types.ModuleType] = None        @staticmethod      def find_default_property(property_list: t.List[t.Dict[str, t.Any]]) -> str:          for property in property_list:              if \"default_property\" in property and property[\"default_property\"] is True:                  return property[\"name\"]          return \"\"        def add_default(self):          current_frame = inspect.currentframe()          error_message = \"Cannot generate elements API for the current module\"          if current_frame is None:              raise RuntimeError(f\"{error_message}: No frame found.\")          if current_frame.f_back is None:              raise RuntimeError(f\"{error_message}: taipy-gui module not found.\")          module_name = current_frame.f_back.f_globals[\"__name__\"]          self.__module = module = sys.modules[module_name]          with open(os.path.abspath(os.path.join(os.path.dirname(__file__), \"..\", \"viselements.json\"))) as viselements:              data = json.load(viselements)              if \"blocks\" not in data or \"controls\" not in data:                  raise RuntimeError(f\"{error_message}: Invalid viselements.json file.\")              for blockElement in data[\"blocks\"]:                  default_property = _ElementApiGenerator.find_default_property(blockElement[1][\"properties\"])                  setattr(                      module,                      blockElement[0],                      _ElementApiGenerator.create_block_api(blockElement[0], blockElement[0], default_property),                  )              for controlElement in data[\"controls\"]:                  default_property = _ElementApiGenerator.find_default_property(controlElement[1][\"properties\"])                  setattr(                      module,                      controlElement[0],                      _ElementApiGenerator.create_control_api(controlElement[0], controlElement[0], default_property),                  )        def add_library(self, library: \"ElementLibrary\"):          library_name = library.get_name()          if self.__module is None:              _TaipyLogger._get_logger().info(                  f\"Python API for extension library '{library_name}' is not available. To fix this, import 'taipy.gui.builder' before importing the extension library.\"  # noqa: E501              )              return          library_module = getattr(self.__module, library_name, None)          if library_module is None:              library_module = types.ModuleType(library_name)              setattr(self.__module, library_name, library_module)          for element_name, element in library.get_elements().items():              setattr(                  library_module,                  element_name,                  _ElementApiGenerator().create_control_api(                      element_name, f\"{library_name}.{element_name}\", element.default_attribute                  ),              )        @staticmethod      def create_block_api(          classname: str,          element_name: str,          default_property: str,      ):          return _ElementApiGenerator.create_element_api(classname, element_name, default_property, _Block)        @staticmethod      def create_control_api(          classname: str,          element_name: str,          default_property: str,      ):          return _ElementApiGenerator.create_element_api(classname, element_name, default_property, _Control)        @staticmethod      def create_element_api(          classname: str,          element_name: str,          default_property: str,          ElementBaseClass: t.Union[t.Type[_Block], t.Type[_Control]],      ):          return type(              classname,              (ElementBaseClass,),              {                  \"__init__\": lambda self, *args, **kwargs: ElementBaseClass.__init__(self, *args, **kwargs),                  \"_ELEMENT_NAME\": element_name,                  \"_DEFAULT_PROPERTY\": default_property,              },          ) "}
{"text": "import typing as t  from abc import ABC, abstractmethod  from os import path    from ..page import Page  from ..utils import _is_in_notebook, _varname_from_content  from ._html import _TaipyHTMLParser    if t.TYPE_CHECKING:      from ..builder._element import _Element      from ..gui import Gui      class _Renderer(Page, ABC):      def __init__(self, **kwargs) -> None:          \"\"\"NOT DOCUMENTED          Initialize a new _Renderer with the indicated content.            Arguments:              content (str): The text content or the path to the file holding the text to be transformed.            If *content* is a path to a readable file, the file is read entirely as the text template.          \"\"\"          from ..builder._element import _Element  # noqa: F811            super().__init__(**kwargs)          content: t.Optional[t.Union[str, _Element]] = kwargs.get(\"content\", None)          if content is None:              raise ValueError(\"'content' argument is missing for class '_Renderer'\")          self._content = \"\"          self._base_element: t.Optional[_Element] = None          self._filepath = \"\"          if isinstance(content, str):              self.__process_content(content)          elif isinstance(content, _Element):              self._base_element = content          else:              raise ValueError(                  f\"'content' argument has incorrect type '{type(content).__name__}'. This must be a string or an Builder element.\"  # noqa: E501              )        def __process_content(self, content: str) -> None:          if path.exists(content) and path.isfile(content):              return self.__parse_file_content(content)          if self._frame is not None:              frame_dir_path = path.dirname(path.abspath(self._frame.f_code.co_filename))              content_path = path.join(frame_dir_path, content)              if path.exists(content_path) and path.isfile(content_path):                  return self.__parse_file_content(content_path)          self._content = content        def __parse_file_content(self, content):          with open(t.cast(str, content), \"r\") as f:              self._content = f.read()              # Save file path for error handling              self._filepath = content        def set_content(self, content: str) -> None:          \"\"\"Set a new page content.            Reads the new page content and reinitializes the `Page^` instance to reflect the change.            !!! important              This function can only be used in an IPython notebook context.            Arguments:              content (str): The text content or the path to the file holding the text to be transformed.                  If *content* is a path to a readable file, the file is read entirely as the text                  template.            Exceptions:              RuntimeError: If this method is called outside an IPython notebook context.          \"\"\"          if not _is_in_notebook():              raise RuntimeError(\"'set_content()' must be used in an IPython notebook context\")          self.__process_content(content)        def _get_content_detail(self, gui: \"Gui\") -> str:          if self._filepath:              return f\"in file '{self._filepath}'\"          if varname := _varname_from_content(gui, self._content):              return f\"in variable '{varname}'\"          return \"\"        @abstractmethod      def render(self, gui: \"Gui\") -> str:          pass      class _EmptyPage(_Renderer):      def __init__(self) -> None:          super().__init__(content=\"<PageContent />\")        def render(self, gui: \"Gui\") -> str:          return self._content      class Markdown(_Renderer):      \"\"\"Page generator for *Markdown* text.        Taipy can use Markdown text to create pages that are the base of      user interfaces.        You can find details on the Taipy Markdown-specific syntax and how to add      Taipy Visual Elements in the [section on HTML](../gui/pages/index.md#using-markdown)      of the User Manual.      \"\"\"        def __init__(self, content: str, **kwargs) -> None:          \"\"\"Initialize a new `Markdown` page.            Arguments:              content (str): The text content or the path to the file holding the Markdown text                  to be transformed.<br/>                  If _content_ is a path to a readable file, the file is read as the Markdown                  template content.          \"\"\"          kwargs[\"content\"] = content          super().__init__(**kwargs)        # Generate JSX from Markdown      def render(self, gui: \"Gui\") -> str:          return gui._markdown.convert(self._content)      class Html(_Renderer):      \"\"\"Page generator for *HTML* text.        Taipy can use HTML code to create pages that are the base of      user interfaces.        You can find details on HTML-specific constructs and how to add      Taipy Visual Elements in the [section on HTML](../gui/pages/index.md#using-html)      of the User Manual.      \"\"\"        def __init__(self, content: str, **kwargs) -> None:          \"\"\"Initialize a new `Html` page.            Arguments:              content (str): The text content or the path to the file holding the HTML text to                  be transformed.<br/>                  If *content* is a path to a readable file, the file is read as the HTML                  template content.          \"\"\"          kwargs[\"content\"] = content          super().__init__(**kwargs)          self.head = None        # Modify path routes      def modify_taipy_base_url(self, base_url):          self._content = self._content.replace(\"{{taipy_base_url}}\", f\"{base_url}\")        # Generate JSX from HTML      def render(self, gui: \"Gui\") -> str:          parser = _TaipyHTMLParser(gui)          parser.feed_data(self._content)          self.head = parser.head          return parser.get_jsx() "}
{"text": "import typing as t    from .._warnings import _warn  from ..gui_types import NumberTypes  from ..utils import _RE_PD_TYPE, _get_date_col_str_name, _MapDict      def _add_to_dict_and_get(dico: t.Dict[str, t.Any], key: str, value: t.Any) -> t.Any:      if key not in dico.keys():          dico[key] = value      return dico[key]      def _get_tuple_val(attr: tuple, index: int, default_val: t.Any) -> t.Any:      return attr[index] if len(attr) > index else default_val      def _get_columns_dict_from_list(      col_list: t.Union[t.List[str], t.Tuple[str]], col_types_keys: t.List[str], value: t.Any  ):      col_dict = {}      idx = 0      for col in col_list:          if col in col_types_keys:              col_dict[col] = {\"index\": idx}              idx += 1          elif col:              _warn(                  f'Error column \"{col}\" is not present in the Dataframe \"{value.head(0) if hasattr(value, \"head\") else value}\".'  # noqa: E501              )      return col_dict      def _get_columns_dict(  # noqa: C901      value: t.Any,      columns: t.Union[str, t.List[str], t.Tuple[str], t.Dict[str, t.Any], _MapDict],      col_types: t.Optional[t.Dict[str, str]] = None,      date_format: t.Optional[str] = None,      number_format: t.Optional[str] = None,      opt_columns: t.Optional[t.Set[str]] = None,  ):      if col_types is None:          return None      col_dict: t.Optional[dict] = None      if isinstance(columns, str):          col_dict = _get_columns_dict_from_list([s.strip() for s in columns.split(\";\")], col_types_keys, value)      elif isinstance(columns, (list, tuple)):          col_dict = _get_columns_dict_from_list(columns, col_types_keys, value)      elif isinstance(columns, _MapDict):          col_dict = columns._dict.copy()      elif isinstance(columns, dict):          col_dict = columns.copy()      if not isinstance(col_dict, dict):          _warn(\"Error: columns attributes should be a string, a list, a tuple or a dict.\")          col_dict = {}      nb_cols = len(col_dict)      if nb_cols == 0:          for col in col_types_keys:              col_dict[col] = {\"index\": nb_cols}              nb_cols += 1      else:          col_dict = {str(k): v for k, v in col_dict.items()}          if opt_columns:              for col in opt_columns:                  if col in col_types_keys and col not in col_dict:                      col_dict[col] = {\"index\": nb_cols}                      nb_cols += 1      idx = 0      for col, ctype in col_types.items():          col = str(col)          if col in col_dict:              re_type = _RE_PD_TYPE.match(ctype)              grps = re_type.groups() if re_type else ()              ctype = grps[0] if grps else ctype              col_dict[col][\"type\"] = ctype              col_dict[col][\"dfid\"] = col              if len(grps) > 4 and grps[4]:                  col_dict[col][\"tz\"] = grps[4]              idx = _add_to_dict_and_get(col_dict[col], \"index\", idx) + 1              if ctype == \"datetime\":                  if date_format:                      _add_to_dict_and_get(col_dict[col], \"format\", date_format)                  col_dict[_get_date_col_str_name(col_types.keys(), col)] = col_dict.pop(col)  # type: ignore              elif number_format and ctype in NumberTypes:                  _add_to_dict_and_get(col_dict[col], \"format\", number_format)      return col_dict "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from __future__ import annotations    from datetime import date, datetime, time  from json import JSONEncoder  from pathlib import Path    from flask.json.provider import DefaultJSONProvider    from .._warnings import _warn  from ..icon import Icon  from ..utils import _date_to_string, _MapDict, _TaipyBase      def _default(o):      if isinstance(o, Icon):          return o._to_dict()      if isinstance(o, _MapDict):          return o._dict      if isinstance(o, _TaipyBase):          return o.get()      if isinstance(o, (datetime, date, time)):          return _date_to_string(o)      if isinstance(o, Path):          return str(o)      try:          raise TypeError(f\"Object of type {o.__class__.__name__} is not JSON serializable\")      except Exception as e:          _warn(\"Exception in JSONEncoder\", e)          return None      class _TaipyJsonEncoder(JSONEncoder):      def default(self, o):          return _default(o)      class _TaipyJsonProvider(DefaultJSONProvider):      default = staticmethod(_default)  # type: ignore      sort_keys = False "}
{"text": "from markdown.treeprocessors import Treeprocessor    from ..builder import _Builder      class _Postprocessor(Treeprocessor):      @staticmethod      def extend(md, gui, priority):          instance = _Postprocessor(md)          md.treeprocessors.register(instance, \"taipy\", priority)          instance._gui = gui        def run(self, root):          MD_PARA_CLASSNAME = \"md-para\"          for p in root.iter():              if p.tag == \"p\":                  classes = p.get(\"class\")                  classes = f\"{MD_PARA_CLASSNAME} {classes}\" if classes else MD_PARA_CLASSNAME                  p.set(\"class\", classes)                  p.tag = \"div\"              if p != root:                  p.set(\"key\", _Builder._get_key(p.tag))          return root "}
{"text": "from markdown.inlinepatterns import InlineProcessor    from .factory import _MarkdownFactory      class _ControlPattern(InlineProcessor):      __PATTERN = _MarkdownFactory._TAIPY_START + r\"([a-zA-Z][\\.a-zA-Z_$0-9]*)(.*?)\" + _MarkdownFactory._TAIPY_END        @staticmethod      def extend(md, gui, priority):          instance = _ControlPattern(_ControlPattern.__PATTERN, md)          md.inlinePatterns.register(instance, \"taipy\", priority)          instance._gui = gui        def handleMatch(self, m, data):          return _MarkdownFactory.create_element(self._gui, m.group(1), m.group(2)), m.start(0), m.end(0) "}
{"text": "import re    from markdown.blockprocessors import BlockProcessor    from .factory import _MarkdownFactory      class _StartBlockProcessor(BlockProcessor):      __RE_FENCE_START = re.compile(          _MarkdownFactory._TAIPY_START + r\"([a-zA-Z][\\.a-zA-Z_$0-9]*)\\.start(.*?)\" + _MarkdownFactory._TAIPY_END      )  # start line      __RE_OTHER_FENCE = re.compile(          _MarkdownFactory._TAIPY_START + r\"([a-zA-Z][\\.a-zA-Z_$0-9]*)\\.(start|end)(.*?)\" + _MarkdownFactory._TAIPY_END      )  # start or end tag        @staticmethod      def extend(md, gui, priority):          instance = _StartBlockProcessor(md.parser)          md.parser.blockprocessors.register(instance, \"taipy\", priority)          instance._gui = gui        def test(self, parent, block):          return re.match(_StartBlockProcessor.__RE_FENCE_START, block)        def run(self, parent, blocks):          original_block = blocks[0]          original_match = re.search(_StartBlockProcessor.__RE_FENCE_START, original_block)          blocks[0] = re.sub(_StartBlockProcessor.__RE_FENCE_START, \"\", blocks[0], 1)          tag = original_match.group(1)          queue = [tag]          # Find block with ending fence          for block_num, block in enumerate(blocks):              matches = re.findall(_StartBlockProcessor.__RE_OTHER_FENCE, block)              for match in matches:                  if queue[-1] == match[0] and match[1] == \"end\":                      queue.pop()                  elif match[1] == \"start\":                      queue.append(match[0])              if not queue:                  # remove end fence                  blocks[block_num] = re.sub(                      _MarkdownFactory._TAIPY_START + tag + r\"\\.end(.*?)\" + _MarkdownFactory._TAIPY_END,                      \"\",                      block,                      1,                  )                  # render fenced area inside a new div                  e = _MarkdownFactory.create_element(self._gui, original_match.group(1), original_match.group(2))                  parent.append(e)                  # parse inside blocks                  self.parser.parseBlocks(e, blocks[: block_num + 1])                  # remove used blocks                  del blocks[: block_num + 1]                  return True  # or could have had no return statement          # No closing marker!  Restore and do nothing          blocks[0] = original_block          return False  # equivalent to our test() routine returning False "}
{"text": "from typing import Any    from markdown.extensions import Extension    from .blocproc import _StartBlockProcessor  from .control import _ControlPattern  from .postproc import _Postprocessor  from .preproc import _Preprocessor      class _TaipyMarkdownExtension(Extension):      config = {\"gui\": [\"\", \"Gui object for extension\"]}        def extendMarkdown(self, md):          from ...gui import Gui            gui = self.config[\"gui\"][0]          if not isinstance(gui, Gui):              raise RuntimeError(\"Gui instance is not bound to Markdown Extension\")          md.registerExtension(self)          _Preprocessor.extend(md, gui, 210)          _ControlPattern.extend(md, gui, 205)          _StartBlockProcessor.extend(md, gui, 175)          _Postprocessor.extend(md, gui, 200) "}
{"text": "import typing as t    from ..factory import _Factory      class _MarkdownFactory(_Factory):      # Taipy Markdown tags      _TAIPY_START = \"TaIpY:\"      _TAIPY_END = \":tAiPy\"        _TAIPY_BLOCK_TAGS = [\"layout\", \"part\", \"expandable\", \"dialog\", \"pane\"]        @staticmethod      def create_element(gui, control_type: str, all_properties: str) -> t.Union[t.Any, str]:          # Create properties dict from all_properties          property_pairs = _Factory._PROPERTY_RE.findall(all_properties)          properties = {property[0]: property[1] for property in property_pairs}          builder_md = _Factory.call_builder(gui, control_type, properties)          if builder_md is None:              return f\"<|INVALID SYNTAX - Control is '{control_type}'|>\"          return builder_md "}
{"text": "from .parser import _TaipyHTMLParser "}
{"text": "import typing as t    from ..factory import _Factory      class _HtmlFactory(_Factory):      @staticmethod      def create_element(gui, namespace: str, control_type: str, all_properties: t.Dict[str, str]) -> t.Tuple[str, str]:          builder_html = _Factory.call_builder(gui, f\"{namespace}.{control_type}\", all_properties, True)          if builder_html is None:              return f\"<div>INVALID SYNTAX - Control is '{namespace}:{control_type}'</div>\", \"div\"          return builder_html  # type: ignore "}
{"text": "import re  import typing as t  from html.parser import HTMLParser    from ..._warnings import _warn  from .factory import _HtmlFactory      class _TaipyHTMLParser(HTMLParser):      __TAIPY_NAMESPACE_RE = re.compile(r\"([a-zA-Z\\_]+):([a-zA-Z\\_]*)\")        def __init__(self, gui):          super().__init__()          self._gui = gui          self.body = \"\"          self.head = []          self.taipy_tag = None          self.tag_mapping = {}          self.is_body = True          self.head_tag = None          self._line_count = 0          self._tag_queue = []        # @override      def handle_starttag(self, tag, props) -> None:          self._tag_queue.append((tag, self._line_count))          if tag == \"html\":              return          if self.head_tag is not None:              self.head.append(self.head_tag)              self.head_tag = None          if self.taipy_tag is not None:              self.parse_taipy_tag()          if tag == \"head\":              self.is_body = False          elif tag == \"body\":              self.is_body = True          elif m := self.__TAIPY_NAMESPACE_RE.match(tag):              self.taipy_tag = _TaipyTag(m.group(1), m.group(2), props)          elif not self.is_body:              head_props = {prop[0]: prop[1] for prop in props}              self.head_tag = {\"tag\": tag, \"props\": head_props, \"content\": \"\"}          else:              self.append_data(str(self.get_starttag_text()))        # @override      def handle_data(self, data: str) -> None:          data = data.strip()          if data and self.taipy_tag is not None and self.taipy_tag.set_value(data):              self.parse_taipy_tag()          elif not self.is_body and self.head_tag is not None:              self.head_tag[\"content\"] = data          else:              self.append_data(data)        # @override      def handle_endtag(self, tag) -> None:          if not self._tag_queue:              _warn(f\"Closing '{tag}' at line {self._line_count} is missing an opening tag.\")          else:              opening_tag, opening_tag_line = self._tag_queue.pop()              if opening_tag != tag:                  _warn(                      f\"Opening tag '{opening_tag}' at line {opening_tag_line} has no matching closing tag '{tag}' at line {self._line_count}.\"  # noqa: E501                  )          if tag in [\"head\", \"body\", \"html\"]:              return          if self.taipy_tag is not None:              self.parse_taipy_tag()          if not self.is_body:              self.head.append(self.head_tag)              self.head_tag = None          elif tag in self.tag_mapping:              self.append_data(f\"</{self.tag_mapping[tag]}>\")          else:              self.append_data(f\"</{tag}>\")        def append_data(self, data: str) -> None:          if self.is_body:              self.body += data        def parse_taipy_tag(self) -> None:          tp_string, tp_element_name = self.taipy_tag.parse(self._gui)          self.append_data(tp_string)          self.tag_mapping[f\"{self.taipy_tag.namespace}:{self.taipy_tag.control_type}\"] = tp_element_name          self.taipy_tag = None        def get_jsx(self) -> str:          return self.body        def feed_data(self, data: str):          data_lines = data.split(\"\\n\")          for line, data_line in enumerate(data_lines):              self._line_count = line + 1              self.feed(data_line)          while self._tag_queue:              opening_tag, opening_tag_line = self._tag_queue.pop()              _warn(f\"Opening tag '{opening_tag}' at line {opening_tag_line} has no matching closing tag.\")      class _TaipyTag(object):      def __init__(self, namespace: str, tag_name: str, properties: t.List[t.Tuple[str, str]]) -> None:          self.namespace = namespace          self.control_type = tag_name          self.properties = {prop[0]: prop[1] for prop in properties}          self.has_set_value = False        def set_value(self, value: str) -> bool:          if self.has_set_value:              return False          property_name = _HtmlFactory.get_default_property_name(f\"{self.namespace}.{self.control_type}\")          # Set property only if it is not already defined          if property_name and property_name not in self.properties.keys():              self.properties[property_name] = value          self.has_set_value = True          return True        def parse(self, gui) -> t.Tuple[str, str]:          for k, v in self.properties.items():              self.properties[k] = v if v is not None else \"true\"          # allow usage of 'class' property in html taipy tag          if \"class\" in self.properties and \"class_name\" not in self.properties:              self.properties[\"class_name\"] = self.properties[\"class\"]          return _HtmlFactory.create_element(gui, self.namespace, self.control_type, self.properties) "}
{"text": "\"\"\"The setup script.\"\"\"    import json  import os    from setuptools import find_namespace_packages, find_packages, setup    with open(\"README.md\", \"rb\") as readme_file:      readme = readme_file.read().decode(\"UTF-8\")    with open(f\"src{os.sep}taipy{os.sep}templates{os.sep}version.json\") as version_file:      version = json.load(version_file)      version_string = f'{version.get(\"major\", 0)}.{version.get(\"minor\", 0)}.{version.get(\"patch\", 0)}'      if vext := version.get(\"ext\"):          version_string = f\"{version_string}.{vext}\"    test_requirements = [\"pytest>=3.8\"]    setup(      author=\"Avaiga\",      author_email=\"dev@taipy.io\",      python_requires=\">=3.8\",      classifiers=[          \"Intended Audience :: Developers\",          \"License :: OSI Approved :: Apache Software License\",          \"Natural Language :: English\",          \"Programming Language :: Python :: 3\",          \"Programming Language :: Python :: 3.8\",          \"Programming Language :: Python :: 3.9\",          \"Programming Language :: Python :: 3.10\",          \"Programming Language :: Python :: 3.11\",      ],      description=\"An open-source package holding Taipy application templates.\",      license=\"Apache License 2.0\",      long_description=readme,      long_description_content_type=\"text/markdown\",      keywords=\"taipy-templates\",      name=\"taipy-templates\",      package_dir={\"\": \"src\"},      packages=find_namespace_packages(where=\"src\") + find_packages(include=[\"taipy\"]),      include_package_data=True,      test_suite=\"tests\",      url=\"https://github.com/avaiga/taipy-templates\",      version=version_string,      zip_safe=False,  ) "}
{"text": "from config.config import configure  from pages import job_page, scenario_page  from pages.root import content, root, selected_data_node, selected_scenario    import taipy as tp  from taipy import Core, Gui      def on_init(state):      ...      def on_change(state, var, val):      if var == \"selected_data_node\" and val:          state[\"scenario\"].manage_data_node_partial(state)      pages = {      \"/\": root,      \"scenario\": scenario_page,      \"jobs\": job_page,  }      if __name__ == \"__main__\":      # Instantiate, configure and run the Core      core = Core()      default_scenario_cfg = configure()      core.run()        # ##################################################################################################################      # PLACEHOLDER: Initialize your data application here                                                               #      #                                                                                                                  #      # Example:                                                                                                         #      if len(tp.get_scenarios()) == 0:          tp.create_scenario(default_scenario_cfg, name=\"Default Scenario\")      # Comment, remove or replace the previous lines with your own use case                                             #      # ##################################################################################################################        # Instantiate, configure and run the GUI      gui = Gui(pages=pages)      data_node_partial = gui.add_partial(\"\")      gui.run(title=\"{{cookiecutter.__application_title}}\", margin=\"0em\") "}
{"text": "from algos import clean_data    from taipy import Config, Frequency, Scope      def configure():      # ##################################################################################################################      # PLACEHOLDER: Add your scenario configurations here                                                               #      #                                                                                                                  #      # Example:                                                                                                         #      initial_dataset_cfg = Config.configure_csv_data_node(\"initial_dataset\", scope=Scope.CYCLE)      replacement_type_cfg = Config.configure_data_node(\"replacement_type\", default_data=\"NO VALUE\")      cleaned_dataset_cfg = Config.configure_csv_data_node(\"cleaned_dataset\")      clean_data_cfg = Config.configure_task(          \"clean_data\",          function=clean_data,          input=[initial_dataset_cfg, replacement_type_cfg],          output=cleaned_dataset_cfg,      )      scenario_cfg = Config.configure_scenario(          \"scenario_configuration\", task_configs=[clean_data_cfg], frequency=Frequency.DAILY      )      return scenario_cfg      # Comment, remove or replace the previous lines with your own use case                                             #      # ################################################################################################################## "}
{"text": "from taipy import Config      def configure():      Config.load(\"config/config.toml\")      return Config.scenarios[\"scenario_configuration\"] "}
{"text": ""}
{"text": "def clean_data(df, replacement_type):      df = df.fillna(replacement_type)      return df "}
{"text": "from .algos import clean_data "}
{"text": "from .job_page import job_page  from .scenario_page import scenario_page "}
{"text": "from taipy.gui import Markdown    selected_scenario = None  selected_data_node = None  content = \"\"    root = Markdown(\"pages/root.md\") "}
{"text": "from .job_page import job_page "}
{"text": "from taipy.gui import Markdown    job_page = Markdown(\"pages/job_page/job_page.md\") "}
{"text": "from taipy.gui import Markdown, notify    from .data_node_management import manage_partial      def notify_on_submission(state, submitable, details):      if details[\"submission_status\"] == \"COMPLETED\":          notify(state, \"success\", \"Submision completed!\")      elif details[\"submission_status\"] == \"FAILED\":          notify(state, \"error\", \"Submission failed!\")      else:          notify(state, \"info\", \"In progress...\")      def manage_data_node_partial(state):      manage_partial(state)      scenario_page = Markdown(\"pages/scenario_page/scenario_page.md\") "}
{"text": "from .scenario_page import scenario_page "}
{"text": "# build partial content for a specific data node  def build_dn_partial(dn, dn_label):      partial_content = \"<|part|render={selected_scenario}|\\n\\n\"        # ##################################################################################################################      # PLACEHOLDER: data node specific content before automatic content                                                 #      #                                                                                                                  #      # Example:                                                                                                         #      if dn_label == \"replacement_type\":          partial_content += \"All missing values will be replaced by the data node value.\"      # Comment, remove or replace the previous lines with your own use case                                             #      # ##################################################################################################################        # Automatic data node content      partial_content += (          \"<|{selected_scenario.data_nodes['\" + dn.config_id + \"']}|data_node|scenario={\" \"selected_scenario}|>\\n\\n \"      )        # ##################################################################################################################      # PLACEHOLDER: data node specific content after automatic content                                                  #      #                                                                                                                  #      # Example:                                                                                                         #      if dn_label == \"initial_dataset\":          partial_content += (              \"Select your CSV file: <|{selected_data_node.path}|file_selector|extensions=.csv|on_action\"              \"={lambda s: s.refresh('selected_scenario')}|>\\n\\n \"          )      # Comment, remove or replace the previous lines with your own use case                                             #      # ##################################################################################################################        partial_content += \"|>\\n\\n\"      return partial_content      def manage_partial(state):      dn = state.selected_data_node      dn_label = dn.get_simple_label()      partial_content = build_dn_partial(dn, dn_label)      state.data_node_partial.update_content(state, partial_content) "}
{"text": "import os    import taipy    # Add taipy version to requirements.txt  with open(os.path.join(os.getcwd(), \"requirements.txt\"), \"a\") as requirement_file:      requirement_file.write(f\"taipy=={taipy.version._get_version()}\\n\")    # Use TOML config file or not  use_toml_config = \"{{ cookiecutter.__use_toml_config }}\".upper()  if use_toml_config == \"YES\" or use_toml_config == \"Y\":      os.remove(os.path.join(os.getcwd(), \"config\", \"config.py\"))      os.rename(          os.path.join(os.getcwd(), \"config\", \"config_with_toml.py\"), os.path.join(os.getcwd(), \"config\", \"config.py\")      )  else:      os.remove(os.path.join(os.getcwd(), \"config\", \"config_with_toml.py\"))      os.remove(os.path.join(os.getcwd(), \"config\", \"config.toml\"))    main_file_name = \"{{cookiecutter.__main_file}}.py\"  print(      f\"New Taipy application has been created at {os.path.join(os.getcwd())}\"      f\"\\n\\nTo start the application, change directory to the newly created folder:\"      f\"\\n\\tcd {os.path.join(os.getcwd())}\"      f\"\\nand run the application as follows:\"      f\"\\n\\ttaipy run {main_file_name}\"  ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import subprocess  import sys      def _run_template(main_path, time_out=30):      \"\"\"Run the templates on a subprocess and get stdout after timeout\"\"\"      with subprocess.Popen([sys.executable, main_path], stdout=subprocess.PIPE, stderr=subprocess.PIPE) as proc:          try:              stdout, stderr = proc.communicate(timeout=time_out)          except subprocess.TimeoutExpired:              proc.kill()              stdout, stderr = proc.communicate()        # Print the error if there is any (for debugging)      if stderr := str(stderr, \"utf-8\"):          print(stderr)        return stdout "}
{"text": "import os    from cookiecutter.main import cookiecutter    from .utils import _run_template      def test_scenario_management_with_toml_config(tmpdir):      cookiecutter(          template=\"src/taipy/templates/scenario-management\",          output_dir=tmpdir,          no_input=True,          extra_context={              \"Application root folder name\": \"foo_app\",              \"Application main Python file\": \"main.py\",              \"Application title\": \"bar\",              \"Does the application use TOML Config?\": \"yes\",          },      )        assert os.listdir(tmpdir) == [\"foo_app\"]      assert (          os.listdir(os.path.join(tmpdir, \"foo_app\")).sort()          == [\"requirements.txt\", \"main.py\", \"algos\", \"config\", \"pages\"].sort()      )        # Assert post_gen_project hook is successful      with open(os.path.join(tmpdir, \"foo_app\", \"requirements.txt\")) as requirements_file:          assert \"taipy==\" in requirements_file.read()      assert (          os.listdir(os.path.join(tmpdir, \"foo_app\", \"config\")).sort()          == [\"__init__.py\", \"config.py\", \"config.toml\"].sort()      )      with open(os.path.join(tmpdir, \"foo_app\", \"config\", \"config.py\")) as config_file:          assert 'Config.load(\"config/config.toml\")' in config_file.read()        oldpwd = os.getcwd()      os.chdir(os.path.join(tmpdir, \"foo_app\"))      stdout = _run_template(\"main.py\")      os.chdir(oldpwd)        # Assert the message when the application is run successfully is in the stdout      assert \"[Taipy][INFO] Configuration 'config/config.toml' successfully loaded.\" in str(stdout, \"utf-8\")      assert \"[Taipy][INFO]  * Server starting on\" in str(stdout, \"utf-8\")      def test_scenario_management_without_toml_config(tmpdir):      cookiecutter(          template=\"src/taipy/templates/scenario-management\",          output_dir=tmpdir,          no_input=True,          extra_context={              \"Application root folder name\": \"foo_app\",              \"Application main Python file\": \"main.py\",              \"Application title\": \"bar\",              \"Does the application use TOML Config?\": \"no\",          },      )        assert os.listdir(tmpdir) == [\"foo_app\"]      assert (          os.listdir(os.path.join(tmpdir, \"foo_app\")).sort()          == [\"requirements.txt\", \"main.py\", \"algos\", \"config\", \"pages\"].sort()      )        # Assert post_gen_project hook is successful      with open(os.path.join(tmpdir, \"foo_app\", \"requirements.txt\")) as requirements_file:          assert \"taipy==\" in requirements_file.read()      assert os.listdir(os.path.join(tmpdir, \"foo_app\", \"config\")).sort() == [\"__init__.py\", \"config.py\"].sort()      with open(os.path.join(tmpdir, \"foo_app\", \"config\", \"config.py\")) as config_file:          config_content = config_file.read()          assert 'Config.load(\"config/config.toml\")' not in config_content          assert all([x in config_content for x in [\"Config.configure_csv_data_node\", \"Config.configure_task\"]])        oldpwd = os.getcwd()      os.chdir(os.path.join(tmpdir, \"foo_app\"))      stdout = _run_template(\"main.py\")      os.chdir(oldpwd)        # Assert the message when the application is run successfully is in the stdout      assert \"[Taipy][INFO]  * Server starting on\" in str(stdout, \"utf-8\") "}
{"text": ""}
{"text": "\"\"\"  Contain the application's configuration including the scenario configurations.    The configuration is run by the Core service.  \"\"\"    from algorithms import *    from taipy import Config    # #############################################################################  # PLACEHOLDER: Put your application's configurations here                     #  #                                                                             #  # Example:                                                                    #  # scenario_config = Config.configure_scenario(\"placeholder_scenario\", [])     #  # Comment, remove or replace the previous lines with your own use case        #  # ############################################################################# "}
{"text": "from .config import * "}
{"text": "\"\"\"  This file is designed to contain the various Python functions used to configure tasks.    The functions will be imported by the __init__.py file in this folder.  \"\"\"    # ##################################################################################################################  # PLACEHOLDER: Put your Python functions here                                                                      #  #                                                                                                                  #  # Example:                                                                                                         #  # def place_holder_algorithm():                                                                                    #  #     pass                                                                                                         #  # Comment, remove or replace the previous lines with your own use case                                             #  # ################################################################################################################## "}
{"text": "from algorithms import * "}
{"text": "from .root import root_page "}
{"text": "\"\"\"  The root page of the application.  Page content is imported from the root.md file.    Please refer to https://docs.taipy.io/en/latest/manuals/gui/pages for more details.  \"\"\"    from taipy.gui import Markdown    root_page = Markdown(\"pages/root.md\") "}
{"text": "\"\"\"  A page of the application.  Page content is imported from the page_example.md file.    Please refer to https://docs.taipy.io/en/latest/manuals/gui/pages for more details.  \"\"\"    from taipy.gui import Markdown    page_example = Markdown(\"pages/page_example/page_example.md\") "}
{"text": "import sys    pages = \"{{ cookiecutter.__pages }}\".split(\" \")  # Remove empty string from pages list  pages = [page for page in pages if page != \"\"]    for page in pages:      if not page.isidentifier():          sys.exit(f'Page name \"{page}\" is not a valid Python identifier. Please choose another name.') "}
{"text": "from ._GuiCoreLib import _GuiCore      def _init_gui_core():      from taipy.gui import Gui        Gui.add_library(_GuiCore())      _init_gui_core() "}
{"text": "from ._init import * "}
{"text": "import json  import os      def _get_version():      with open(f\"{os.path.dirname(os.path.abspath(__file__))}{os.sep}version.json\") as version_file:          version = json.load(version_file)          version_string = f'{version.get(\"major\", 0)}.{version.get(\"minor\", 0)}.{version.get(\"patch\", 0)}'          if vext := version.get(\"ext\"):              version_string = f\"{version_string}.{vext}\"      return version_string "}
{"text": "from .rest import Rest "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from taipy.config import Config    from .app import create_app as _create_app      class Rest:      \"\"\"      Runnable Rest application serving REST APIs on top of Taipy Core functionalities.      \"\"\"        def __init__(self):          \"\"\"          Initialize a REST API server.            A Flask application is instantiated and configured using three parameters from the global          config.              - Config.global_config.testing (bool): Run the application on testing mode.              - Config.global_config.env (Optional[str]): The application environment.              - Config.global_config.secret_key (Optional[str]): Application server secret key.            However, editing these parameters is only recommended for advanced users. Indeed, the default behavior of the          REST server without any required configuration satisfies all the standard and basic needs.          \"\"\"          self._app = _create_app(              Config.global_config.testing or False, Config.global_config.env, Config.global_config.secret_key          )        def run(self, **kwargs):          \"\"\"          Start a REST API server. This method is blocking.            Parameters:              **kwargs : Options to provide to the application server.          \"\"\"          self._app.run(**kwargs) "}
{"text": "\"\"\"# Taipy Rest    The Taipy Rest package exposes the Runnable `Rest^` service to provide REST APIs on top of Taipy Core. (more details  on Taipy Core functionalities in the [user manual](../../../manuals/core/)).    Once the `Rest^` service runs, users can call REST APIs to create, read, update, submit and remove Taipy entities  (including cycles, scenarios, sequences, tasks, jobs, and data nodes). It is handy when it comes to integrating a  Taipy application in a more complex IT ecosystem.    Please refer to [REST API](../../reference_rest/) page to get the exhaustive list of available APIs.\"\"\"    from ._init import *  from .version import _get_version    __version__ = _get_version() "}
{"text": "\"\"\"Extensions registry    All extensions here are used as singletons and  initialized in application factory  \"\"\"    from .commons.apispec import APISpecExt    apispec = APISpecExt() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  import json  import os    from setuptools import find_namespace_packages, find_packages, setup    with open(\"README.md\") as readme_file:      readme = readme_file.read()    with open(f\"src{os.sep}taipy{os.sep}rest{os.sep}version.json\") as version_file:      version = json.load(version_file)      version_string = f'{version.get(\"major\", 0)}.{version.get(\"minor\", 0)}.{version.get(\"patch\", 0)}'      if vext := version.get(\"ext\"):          version_string = f\"{version_string}.{vext}\"    setup(      author=\"Avaiga\",      name=\"taipy-rest\",      keywords=\"taipy-rest\",      python_requires=\">=3.8\",      version=version_string,      author_email=\"dev@taipy.io\",      packages=find_namespace_packages(where=\"src\") + find_packages(include=[\"taipy\", \"taipy.rest\"]),      package_dir={\"\": \"src\"},      include_package_data=True,      long_description=readme,      long_description_content_type=\"text/markdown\",      description=\"Library to expose taipy-core REST APIs.\",      license=\"Apache License 2.0\",      classifiers=[          \"Intended Audience :: Developers\",          \"License :: OSI Approved :: Apache Software License\",          \"Natural Language :: English\",          \"Programming Language :: Python :: 3\",          \"Programming Language :: Python :: 3.8\",          \"Programming Language :: Python :: 3.9\",          \"Programming Language :: Python :: 3.10\",          \"Programming Language :: Python :: 3.11\",      ],      install_requires=[          \"flask>=3.0.0,<3.1\",          \"flask-restful>=0.3.9,<0.4\",          \"passlib>=1.7.4,<1.8\",          \"marshmallow>=3.20.1,<3.30\",          \"apispec[yaml]>=6.3,<7.0\",          \"apispec-webframeworks>=0.5.2,<0.6\",          \"taipy-core@git+https://git@github.com/Avaiga/taipy-core.git@develop\",      ],  ) "}
{"text": "import os    from flask import Flask    from . import api  from .commons.encoder import _CustomEncoder  from .extensions import apispec      def create_app(testing=False, flask_env=None, secret_key=None):      \"\"\"Application factory, used to create application\"\"\"      app = Flask(__name__)      app.config.update(          ENV=os.getenv(\"FLASK_ENV\", flask_env),          TESTING=os.getenv(\"TESTING\", testing),          SECRET_KEY=os.getenv(\"SECRET_KEY\", secret_key),      )      app.url_map.strict_slashes = False      app.config[\"RESTFUL_JSON\"] = {\"cls\": _CustomEncoder}        configure_apispec(app)      register_blueprints(app)      with app.app_context():          api.views.register_views()        return app      def configure_apispec(app):      \"\"\"Configure APISpec for swagger support\"\"\"      apispec.init_app(app)        apispec.spec.components.schema(          \"PaginatedResult\",          {              \"properties\": {                  \"total\": {\"type\": \"integer\"},                  \"pages\": {\"type\": \"integer\"},                  \"next\": {\"type\": \"string\"},                  \"prev\": {\"type\": \"string\"},              }          },      )      def register_blueprints(app):      \"\"\"Register all blueprints for application\"\"\"      app.register_blueprint(api.views.blueprint) "}
{"text": "from taipy.core.cycle._cycle_converter import _CycleConverter  from taipy.core.data._data_converter import _DataNodeConverter  from taipy.core.scenario._scenario_converter import _ScenarioConverter  from taipy.core.sequence._sequence_converter import _SequenceConverter  from taipy.core.task._task_converter import _TaskConverter    entity_to_models = {      \"scenario\": _ScenarioConverter._entity_to_model,      \"sequence\": _SequenceConverter._entity_to_model,      \"task\": _TaskConverter._entity_to_model,      \"data\": _DataNodeConverter._entity_to_model,      \"cycle\": _CycleConverter._entity_to_model,  }      def _to_model(repository, entity, **kwargs):      return entity_to_models[repository](entity) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from apispec import APISpec  from apispec.exceptions import APISpecError  from apispec.ext.marshmallow import MarshmallowPlugin  from apispec_webframeworks.flask import FlaskPlugin  from flask import Blueprint, jsonify, render_template      class FlaskRestfulPlugin(FlaskPlugin):      \"\"\"Small plugin override to handle flask-restful resources\"\"\"        @staticmethod      def _rule_for_view(view, app=None):          view_funcs = app.view_functions          endpoint = None            for ept, view_func in view_funcs.items():              if hasattr(view_func, \"view_class\"):                  view_func = view_func.view_class                if view_func == view:                  endpoint = ept            if not endpoint:              raise APISpecError(\"Could not find endpoint for view {0}\".format(view))            # WARNING: Assume 1 rule per view function for now          rule = app.url_map._rules_by_endpoint[endpoint][0]          return rule      class APISpecExt:      \"\"\"Very simple and small extension to use apispec with this API as a flask extension\"\"\"        def __init__(self, app=None, **kwargs):          self.spec = None            if app is not None:              self.init_app(app, **kwargs)        def init_app(self, app, **kwargs):          app.config.setdefault(\"APISPEC_TITLE\", \"Taipy Rest\")          app.config.setdefault(\"APISPEC_VERSION\", \"1.0.0\")          app.config.setdefault(\"OPENAPI_VERSION\", \"3.0.2\")          app.config.setdefault(\"SWAGGER_JSON_URL\", \"/swagger.json\")          app.config.setdefault(\"SWAGGER_UI_URL\", \"/swagger-ui\")          app.config.setdefault(\"OPENAPI_YAML_URL\", \"/openapi.yaml\")          app.config.setdefault(\"REDOC_UI_URL\", \"/redoc-ui\")          app.config.setdefault(\"SWAGGER_URL_PREFIX\", None)            self.spec = APISpec(              title=app.config[\"APISPEC_TITLE\"],              version=app.config[\"APISPEC_VERSION\"],              openapi_version=app.config[\"OPENAPI_VERSION\"],              plugins=[MarshmallowPlugin(), FlaskRestfulPlugin()],              **kwargs          )            blueprint = Blueprint(              \"swagger\",              __name__,              template_folder=\"./templates\",              url_prefix=app.config[\"SWAGGER_URL_PREFIX\"],          )            blueprint.add_url_rule(app.config[\"SWAGGER_JSON_URL\"], \"swagger_json\", self.swagger_json)          blueprint.add_url_rule(app.config[\"SWAGGER_UI_URL\"], \"swagger_ui\", self.swagger_ui)          blueprint.add_url_rule(app.config[\"OPENAPI_YAML_URL\"], \"openapi_yaml\", self.openapi_yaml)          blueprint.add_url_rule(app.config[\"REDOC_UI_URL\"], \"redoc_ui\", self.redoc_ui)            app.register_blueprint(blueprint)        def swagger_json(self):          return jsonify(self.spec.to_dict())        def swagger_ui(self):          return render_template(\"swagger.j2\")        def openapi_yaml(self):          # Manually inject ReDoc's Authentication legend, then remove it          self.spec.tag(              {                  \"name\": \"authentication\",                  \"x-displayName\": \"Authentication\",                  \"description\": \"<SecurityDefinitions />\",              }          )          redoc_spec = self.spec.to_yaml()          self.spec._tags.pop(0)          return redoc_spec        def redoc_ui(self):          return render_template(\"redoc.j2\") "}
{"text": "import json  from datetime import datetime  from enum import Enum  from typing import Any, Union    Json = Union[dict, list, str, int, float, bool, None]      class _CustomEncoder(json.JSONEncoder):      def default(self, o: Any) -> Json:          if isinstance(o, Enum):              result = o.value          elif isinstance(o, datetime):              result = {\"__type__\": \"Datetime\", \"__value__\": o.isoformat()}          else:              result = json.JSONEncoder.default(self, o)          return result "}
{"text": "\"\"\"Simple helper to paginate query  \"\"\"  from flask import request, url_for    DEFAULT_PAGE_SIZE = 50  DEFAULT_PAGE_NUMBER = 1      def extract_pagination(page=None, per_page=None, **request_args):      page = int(page) if page is not None else DEFAULT_PAGE_NUMBER      per_page = int(per_page) if per_page is not None else DEFAULT_PAGE_SIZE      return page, per_page, request_args      def paginate(query, schema):      page, per_page, other_request_args = extract_pagination(**request.args)      page_obj = query.paginate(page=page, per_page=per_page)      next_ = url_for(          request.endpoint,          page=page_obj.next_num if page_obj.has_next else page_obj.page,          per_page=per_page,          **other_request_args,          **request.view_args      )      prev = url_for(          request.endpoint,          page=page_obj.prev_num if page_obj.has_prev else page_obj.page,          per_page=per_page,          **other_request_args,          **request.view_args      )        return {          \"total\": page_obj.total,          \"pages\": page_obj.pages,          \"next\": next_,          \"prev\": prev,          \"results\": schema.dump(page_obj.items),      } "}
{"text": "from . import error_handler, views    __all__ = [\"views\", \"error_handler\"] "}
{"text": "from flask import jsonify  from marshmallow import ValidationError    from taipy.core.exceptions.exceptions import (      NonExistingCycle,      NonExistingDataNode,      NonExistingDataNodeConfig,      NonExistingJob,      NonExistingScenario,      NonExistingScenarioConfig,      NonExistingSequence,      NonExistingSequenceConfig,      NonExistingTask,      NonExistingTaskConfig,  )    from .exceptions.exceptions import ConfigIdMissingException, ScenarioIdMissingException, SequenceNameMissingException  from .views import blueprint      def _create_404(e):      return {\"message\": e.message}, 404      @blueprint.errorhandler(ValidationError)  def handle_marshmallow_error(e):      \"\"\"Return json error for marshmallow validation errors.        This will avoid having to try/catch ValidationErrors in all endpoints, returning      correct JSON response with associated HTTP 400 Status (https://tools.ietf.org/html/rfc7231#section-6.5.1)      \"\"\"      return jsonify(e.messages), 400      @blueprint.errorhandler(ConfigIdMissingException)  def handle_config_id_missing_exception(e):      return jsonify({\"message\": e.message}), 400      @blueprint.errorhandler(ScenarioIdMissingException)  def handle_scenario_id_missing_exception(e):      return jsonify({\"message\": e.message}), 400      @blueprint.errorhandler(SequenceNameMissingException)  def handle_sequence_name_missing_exception(e):      return jsonify({\"message\": e.message}), 400      @blueprint.errorhandler(NonExistingDataNode)  def handle_data_node_not_found(e):      return _create_404(e)      @blueprint.errorhandler(NonExistingDataNodeConfig)  def handle_data_node_config_not_found(e):      return _create_404(e)      @blueprint.errorhandler(NonExistingCycle)  def handle_cycle_not_found(e):      return _create_404(e)      @blueprint.errorhandler(NonExistingJob)  def handle_job_not_found(e):      return _create_404(e)      @blueprint.errorhandler(NonExistingSequence)  def handle_sequence_not_found(e):      return _create_404(e)      @blueprint.errorhandler(NonExistingSequenceConfig)  def handle_sequence_config_not_found(e):      return _create_404(e)      @blueprint.errorhandler(NonExistingScenario)  def handle_scenario_not_found(e):      return _create_404(e)      @blueprint.errorhandler(NonExistingScenarioConfig)  def handle_scenario_config_not_found(e):      return _create_404(e)      @blueprint.errorhandler(NonExistingTask)  def handle_task_not_found(e):      return _create_404(e)      @blueprint.errorhandler(NonExistingTaskConfig)  def handle_task_config_not_found(e):      return _create_404(e) "}
{"text": "from flask import Blueprint, current_app  from flask_restful import Api    from taipy.core.common._utils import _load_fct  from taipy.logger._taipy_logger import _TaipyLogger    from ..extensions import apispec  from .middlewares._middleware import _using_enterprise  from .resources import (      CycleList,      CycleResource,      DataNodeList,      DataNodeReader,      DataNodeResource,      DataNodeWriter,      JobExecutor,      JobList,      JobResource,      ScenarioExecutor,      ScenarioList,      ScenarioResource,      SequenceExecutor,      SequenceList,      SequenceResource,      TaskExecutor,      TaskList,      TaskResource,  )  from .schemas import CycleSchema, DataNodeSchema, JobSchema, ScenarioSchema, SequenceSchema, TaskSchema    _logger = _TaipyLogger._get_logger()      blueprint = Blueprint(\"api\", __name__, url_prefix=\"/api/v1\")    api = Api(blueprint)    api.add_resource(      DataNodeResource,      \"/datanodes/<string:datanode_id>/\",      endpoint=\"datanode_by_id\",      resource_class_kwargs={\"logger\": _logger},  )    api.add_resource(      DataNodeReader,      \"/datanodes/<string:datanode_id>/read/\",      endpoint=\"datanode_reader\",      resource_class_kwargs={\"logger\": _logger},  )    api.add_resource(      DataNodeWriter,      \"/datanodes/<string:datanode_id>/write/\",      endpoint=\"datanode_writer\",      resource_class_kwargs={\"logger\": _logger},  )    api.add_resource(      DataNodeList,      \"/datanodes/\",      endpoint=\"datanodes\",      resource_class_kwargs={\"logger\": _logger},  )    api.add_resource(      TaskResource,      \"/tasks/<string:task_id>/\",      endpoint=\"task_by_id\",      resource_class_kwargs={\"logger\": _logger},  )    api.add_resource(TaskList, \"/tasks/\", endpoint=\"tasks\", resource_class_kwargs={\"logger\": _logger})  api.add_resource(      TaskExecutor,      \"/tasks/submit/<string:task_id>/\",      endpoint=\"task_submit\",      resource_class_kwargs={\"logger\": _logger},  )    api.add_resource(      SequenceResource,      \"/sequences/<string:sequence_id>/\",      endpoint=\"sequence_by_id\",      resource_class_kwargs={\"logger\": _logger},  )  api.add_resource(      SequenceList,      \"/sequences/\",      endpoint=\"sequences\",      resource_class_kwargs={\"logger\": _logger},  )  api.add_resource(      SequenceExecutor,      \"/sequences/submit/<string:sequence_id>/\",      endpoint=\"sequence_submit\",      resource_class_kwargs={\"logger\": _logger},  )    api.add_resource(      ScenarioResource,      \"/scenarios/<string:scenario_id>/\",      endpoint=\"scenario_by_id\",      resource_class_kwargs={\"logger\": _logger},  )  api.add_resource(      ScenarioList,      \"/scenarios/\",      endpoint=\"scenarios\",      resource_class_kwargs={\"logger\": _logger},  )  api.add_resource(      ScenarioExecutor,      \"/scenarios/submit/<string:scenario_id>/\",      endpoint=\"scenario_submit\",      resource_class_kwargs={\"logger\": _logger},  )    api.add_resource(      CycleResource,      \"/cycles/<string:cycle_id>/\",      endpoint=\"cycle_by_id\",      resource_class_kwargs={\"logger\": _logger},  )  api.add_resource(      CycleList,      \"/cycles/\",      endpoint=\"cycles\",      resource_class_kwargs={\"logger\": _logger},  )    api.add_resource(      JobResource,      \"/jobs/<string:job_id>/\",      endpoint=\"job_by_id\",      resource_class_kwargs={\"logger\": _logger},  )  api.add_resource(JobList, \"/jobs/\", endpoint=\"jobs\", resource_class_kwargs={\"logger\": _logger})  api.add_resource(      JobExecutor,      \"/jobs/cancel/<string:job_id>/\",      endpoint=\"job_cancel\",      resource_class_kwargs={\"logger\": _logger},  )      def load_enterprise_resources(api: Api):      \"\"\"      Load enterprise resources.      \"\"\"        if not _using_enterprise():          return      load_resources = _load_fct(\"taipy.enterprise.rest.api.views\", \"_load_resources\")      load_resources(api)      load_enterprise_resources(api)      def register_views():      apispec.spec.components.schema(\"DataNodeSchema\", schema=DataNodeSchema)      apispec.spec.path(view=DataNodeResource, app=current_app)      apispec.spec.path(view=DataNodeList, app=current_app)      apispec.spec.path(view=DataNodeReader, app=current_app)      apispec.spec.path(view=DataNodeWriter, app=current_app)        apispec.spec.components.schema(\"TaskSchema\", schema=TaskSchema)      apispec.spec.path(view=TaskResource, app=current_app)      apispec.spec.path(view=TaskList, app=current_app)      apispec.spec.path(view=TaskExecutor, app=current_app)        apispec.spec.components.schema(\"SequenceSchema\", schema=SequenceSchema)      apispec.spec.path(view=SequenceResource, app=current_app)      apispec.spec.path(view=SequenceList, app=current_app)      apispec.spec.path(view=SequenceExecutor, app=current_app)        apispec.spec.components.schema(\"ScenarioSchema\", schema=ScenarioSchema)      apispec.spec.path(view=ScenarioResource, app=current_app)      apispec.spec.path(view=ScenarioList, app=current_app)      apispec.spec.path(view=ScenarioExecutor, app=current_app)        apispec.spec.components.schema(\"CycleSchema\", schema=CycleSchema)      apispec.spec.path(view=CycleResource, app=current_app)      apispec.spec.path(view=CycleList, app=current_app)        apispec.spec.components.schema(\"JobSchema\", schema=JobSchema)      apispec.spec.path(view=JobResource, app=current_app)      apispec.spec.path(view=JobList, app=current_app)      apispec.spec.path(view=JobExecutor, app=current_app)        apispec.spec.components.schema(          \"Any\",          {              \"description\": \"Any value\",              \"nullable\": True,          },      )        if _using_enterprise():          _register_views = _load_fct(\"taipy.enterprise.rest.api.views\", \"_register_views\")          _register_views(apispec) "}
{"text": "from .cycle import CycleList, CycleResource  from .datanode import DataNodeList, DataNodeReader, DataNodeResource, DataNodeWriter  from .job import JobExecutor, JobList, JobResource  from .scenario import ScenarioExecutor, ScenarioList, ScenarioResource  from .sequence import SequenceExecutor, SequenceList, SequenceResource  from .task import TaskExecutor, TaskList, TaskResource    __all__ = [      \"DataNodeResource\",      \"DataNodeList\",      \"DataNodeReader\",      \"DataNodeWriter\",      \"TaskList\",      \"TaskResource\",      \"TaskExecutor\",      \"SequenceList\",      \"SequenceResource\",      \"SequenceExecutor\",      \"ScenarioList\",      \"ScenarioResource\",      \"ScenarioExecutor\",      \"CycleResource\",      \"CycleList\",      \"JobResource\",      \"JobList\",      \"JobExecutor\",  ] "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from functools import wraps  from importlib import util    from taipy.core.common._utils import _load_fct      def _middleware(f):      @wraps(f)      def wrapper(*args, **kwargs):          if _using_enterprise():              return _enterprise_middleware()(f)(*args, **kwargs)          else:              return f(*args, **kwargs)        return wrapper      def _using_enterprise():      return util.find_spec(\"taipy.enterprise\") is not None      def _enterprise_middleware():      return _load_fct(\"taipy.enterprise.rest.api.middlewares._middleware\", \"_middleware\") "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "  class ConfigIdMissingException(Exception):      def __init__(self):          self.message = \"Config id is missing.\"      class ScenarioIdMissingException(Exception):      def __init__(self):          self.message = \"Scenario id is missing.\"      class SequenceNameMissingException(Exception):      def __init__(self):          self.message = \"Sequence name is missing.\" "}
{"text": "from marshmallow import Schema, fields      class CycleSchema(Schema):      name = fields.String()      frequency = fields.String()      properties = fields.Dict()      creation_date = fields.String()      start_date = fields.String()      end_date = fields.String()      class CycleResponseSchema(CycleSchema):      id = fields.String() "}
{"text": "from marshmallow import Schema, fields      class TaskSchema(Schema):      config_id = fields.String()      id = fields.String()      owner_id = fields.String()      parent_ids = fields.List(fields.String)      input_ids = fields.List(fields.String)      function_name = fields.String()      function_module = fields.String()      output_ids = fields.List(fields.String)      version = fields.String() "}
{"text": "from marshmallow import Schema, fields      class CallableSchema(Schema):      fct_name = fields.String()      fct_module = fields.String()      class JobSchema(Schema):      id = fields.String()      task_id = fields.String()      status = fields.String()      force = fields.Boolean()      creation_date = fields.String()      subscribers = fields.Nested(CallableSchema)      stacktrace = fields.List(fields.String) "}
{"text": "from marshmallow import Schema, fields      class SequenceSchema(Schema):      owner_id = fields.String()      parent_ids = fields.List(fields.String)      tasks = fields.List(fields.String)      version = fields.String()      properties = fields.Dict()      class SequenceResponseSchema(SequenceSchema):      id = fields.String()      subscribers = fields.List(fields.Dict) "}
{"text": "from .cycle import CycleResponseSchema, CycleSchema  from .datanode import (      CSVDataNodeConfigSchema,      DataNodeConfigSchema,      DataNodeFilterSchema,      DataNodeSchema,      ExcelDataNodeConfigSchema,      GenericDataNodeConfigSchema,      InMemoryDataNodeConfigSchema,      JSONDataNodeConfigSchema,      MongoCollectionDataNodeConfigSchema,      PickleDataNodeConfigSchema,      SQLDataNodeConfigSchema,      SQLTableDataNodeConfigSchema,  )  from .job import JobSchema  from .scenario import ScenarioResponseSchema, ScenarioSchema  from .sequence import SequenceResponseSchema, SequenceSchema  from .task import TaskSchema    __all__ = [      \"DataNodeSchema\",      \"DataNodeFilterSchema\",      \"TaskSchema\",      \"SequenceSchema\",      \"SequenceResponseSchema\",      \"ScenarioSchema\",      \"ScenarioResponseSchema\",      \"CycleSchema\",      \"CycleResponseSchema\",      \"JobSchema\",  ] "}
{"text": "from marshmallow import Schema, fields, pre_dump      class DataNodeSchema(Schema):      config_id = fields.String()      scope = fields.String()      id = fields.String()      storage_type = fields.String()      name = fields.String()      owner_id = fields.String()      parent_ids = fields.List(fields.String)      last_edit_date = fields.String()      job_ids = fields.List(fields.String)      version = fields.String()      cacheable = fields.Boolean()      validity_days = fields.Float()      validity_seconds = fields.Float()      edit_in_progress = fields.Boolean()      properties = fields.Dict()      class DataNodeConfigSchema(Schema):      name = fields.String()      storage_type = fields.String()      scope = fields.Integer()      cacheable = fields.Boolean()        @pre_dump      def serialize_scope(self, obj, **kwargs):          obj.scope = obj.scope.value          return obj      class CSVDataNodeConfigSchema(DataNodeConfigSchema):      path = fields.String()      default_path = fields.String()      has_header = fields.Boolean()      class InMemoryDataNodeConfigSchema(DataNodeConfigSchema):      default_data = fields.Inferred()      class PickleDataNodeConfigSchema(DataNodeConfigSchema):      path = fields.String()      default_path = fields.String()      default_data = fields.Inferred()      class SQLTableDataNodeConfigSchema(DataNodeConfigSchema):      db_name = fields.String()      table_name = fields.String()      class SQLDataNodeConfigSchema(DataNodeConfigSchema):      db_name = fields.String()      read_query = fields.String()      write_query = fields.List(fields.String())      class MongoCollectionDataNodeConfigSchema(DataNodeConfigSchema):      db_name = fields.String()      collection_name = fields.String()      class ExcelDataNodeConfigSchema(DataNodeConfigSchema):      path = fields.String()      default_path = fields.String()      has_header = fields.Boolean()      sheet_name = fields.String()      class GenericDataNodeConfigSchema(DataNodeConfigSchema):      pass      class JSONDataNodeConfigSchema(DataNodeConfigSchema):      path = fields.String()      default_path = fields.String()      class OperatorSchema(Schema):      key = fields.String()      value = fields.Inferred()      operator = fields.String()      class DataNodeFilterSchema(DataNodeConfigSchema):      operators = fields.List(fields.Nested(OperatorSchema))      join_operator = fields.String(default=\"AND\") "}
{"text": "from marshmallow import Schema, fields      class ScenarioSchema(Schema):      sequences = fields.Dict()      properties = fields.Dict()      primary_scenario = fields.Boolean(default=False)      tags = fields.List(fields.String)      version = fields.String()      class ScenarioResponseSchema(ScenarioSchema):      id = fields.String()      subscribers = fields.List(fields.Dict)      cycle = fields.String()      creation_date = fields.String() "}
{"text": "from taipy.gui import Gui  from pages.examples import page_examples    pages = {\"/\":\"\"\"  Cette page est g\u00e9n\u00e9r\u00e9e avec Taipy. Voir taipy.io pour plus d'informations  <|navbar|>\"\"\",  \"Examples\":page_examples}    if __name__==\"__main__\":      gui = Gui(pages=pages)      gui.run(port=5006) "}
{"text": "import tensorflow as tf  import tensorflow.keras.preprocessing.image as imgtf  import numpy as np  from io import BytesIO    def load_model(local_model_path):      model = tf.keras.models.load_model(local_model_path,                                         custom_objects={\"iou_coef\":iou_coef}                                        )      return model    def convert_mask_to_color(masks):      '''      Convert a array of mask (height,width,8) in color visualisation array (height,width,3)      '''      dic_color = {          0 : [76,0,153], # flat          1 : [0,0,204], # vehicle          2 : [96,96,96], # construction          3 : [224,224,224], # object          4 : [0,204,0], # nature          5 : [255,0,0], # human          6 : [153,255,255], # sky          7 : [0,0,0] # void      }      dic_r = {k:dic_color[k][0] for k in dic_color.keys()}      dic_g = {k:dic_color[k][1] for k in dic_color.keys()}      dic_b = {k:dic_color[k][2] for k in dic_color.keys()}            id_mask = np.argmax(masks,axis=-1)      color_masks_r = np.vectorize(dic_r.__getitem__)(id_mask)      color_masks_g = np.vectorize(dic_g.__getitem__)(id_mask)      color_masks_b= np.vectorize(dic_b.__getitem__)(id_mask)      color_masks = np.stack((color_masks_r,color_masks_g,color_masks_b),axis=-1)      return color_masks    def make_predict(X,model):      '''      Load the image store as static/image_submit.png and convert to an array      Load the model and make a prediction      Convert the masks array into a image and store it      '''            ### Prediction      y_pred = model.predict(X)      masks = y_pred[0,]      image_masks = convert_mask_to_color(masks)      image_to_save = imgtf.array_to_img(image_masks)      buf = BytesIO()        tf.keras.utils.save_img(buf, image_to_save,                              data_format=\"channels_last\",                              file_format=\"PNG\")      byte_im = buf.getvalue()      return byte_im      ###    def iou_coef(y_true, y_pred, smooth=1e-1):        y_pred = tf.convert_to_tensor(y_pred)      y_pred = tf.cast(y_pred, tf.float32)      y_true = tf.cast(y_true, tf.float32)      smooth = tf.cast(smooth, tf.float32)        y_true_f = K.flatten(y_true)      y_pred_f = K.flatten(y_pred)        intersection = K.sum(y_true_f * y_pred_f)      union = K.sum(y_true_f) + K.sum(y_pred_f) - intersection      iou = (intersection + smooth) / (union + smooth)      return iou"}
{"text": "from taipy.gui import Markdown  import time  from prediction_function.predmodel import *  import tensorflow as tf  import tensorflow.keras.backend as K  from io import BytesIO    image_originale = None  image_traitee = None  image_solution = None  ville=None  inference_time = 0.    model = load_model(\"./model/unet_vgg16_v3_256_2Aug\")    def load_image(path_img):      dimension = (256, 256)      X = np.empty((1, *dimension, 3), dtype=\"uint8\")      image = imgtf.load_img(path_img,      color_mode=\"rgb\",      target_size=dimension, # Depends of the model trained      interpolation=\"nearest\",      )      X[0,] = image      return X    liste_ville = [      (\"./static/examples/frankfurt_000000_001016\",\"Frankfurt\"),      (\"./static/examples/lindau_000000_000019\",\"Lindau\"),      (\"./static/examples/munster_000046_000019\",\"Munster\")  ]    def on_change_selector(state):        path_img = state.ville[0]+\"_leftImg8bit.png\"      X = load_image(path_img)        t0 = time.time()      byte_im = make_predict(X,model)      inference_time = round(time.time() - t0,2)        print(\"inference\")        state.image_originale = path_img      state.image_traitee = byte_im      state.image_solution = state.ville[0]+\"_mask_colors.png\"      state.inference_time = inference_time        print(\"finish\")      page_examples = Markdown(\"\"\"  # Exemple d'application de segmentation s\u00e9mantique    Cette d\u00e9mo utilise un mod\u00e8le Unet (avec encodeur VGG16) pour de la segmentation s\u00e9mantique    # S\u00e9lection de l'image example    <|{ville}|selector|lov={liste_ville}|on_change=on_change_selector|>    # Affichage du r\u00e9sultat    <|{image_originale}|image|label=L'image originale|>  <|{image_traitee}|image|label=La segmentation issue du mod\u00e8le|>  <|{image_solution}|image|label=Le r\u00e9sultat cible|>    Le tout a pris <|{inference_time}|>s pour s'executer.    \"\"\")"}
{"text": "msg = \"Hello world\"  print(msg) "}
{"text": "from taipy.gui import Gui  from math import cos, exp     page = \"\"\"  #This is *Taipy* GUI     A value: <|{decay}|>.    A slider: <br/>  <|{decay}|slider|>    My chart:   <|{data}|chart|>  \"\"\"    def compute_data(decay):      return [cos(i/16) * exp(-i*decay/6000) for i in range(720)]    def on_change(state, var_name, var_value):      if var_name == 'decay':          state.data = compute_data(var_value)    decay = 10  data = compute_data(decay)     Gui(page=page).run(title='Taipy Demo GUI 1',      \t\t       dark_mode=False)"}
{"text": "import json  import time    import requests  import pandas as pd  from taipy.gui import Gui, notify    API_KEY = \"ADD YOUR OPENAI API KEY HERE\"  INITIAL_PROMPT = \"I am a helpful assistant.\"  MAX_TOKENS = 150    API_ENDPOINT = \"https://api.openai.com/v1/chat/completions\"      def generate_completion(messages, model=\"gpt-4\", temperature=1):      headers = {          \"Content-Type\": \"application/json\",          \"Authorization\": f\"Bearer {API_KEY}\",      }        data = {          \"model\": model,          \"messages\": messages,          \"temperature\": temperature,      }        data[\"max_tokens\"] = MAX_TOKENS        response = requests.post(API_ENDPOINT, headers=headers, data=json.dumps(data))        if response.status_code == 200:          return response.json()[\"choices\"][0][\"message\"][\"content\"]      else:          return \"I'm sorry, GPT-4 is not available right now.\"      saved_messages = [      {\"role\": \"system\", \"content\": INITIAL_PROMPT},  ]    user_message = \"\"      def messages_to_data(messages):      result = []      for message in messages:          result_message = {}          result_message[\"Role\"] = message[\"role\"]          result_message[\"Message\"] = message[\"content\"]          if result_message[\"Role\"] == \"system\":              result_message[\"Role\"] = \"GPT-4\"          else:              result_message[\"Role\"] = \"You\"          result.append(result_message)      return pd.DataFrame(result)      def on_send_click(state):      notify(state, \"info\", \"Generating response...\")      message = state.user_message      state.saved_messages.append({\"role\": \"user\", \"content\": message})      state.saved_messages = state.saved_messages      state.user_message = \"\"      time.sleep(0.1)      response = generate_completion(state.saved_messages)      state.saved_messages.append({\"role\": \"system\", \"content\": response})      state.saved_messages = state.saved_messages      notify(state, \"success\", \"GPT-4 generated a response!\")      page = \"\"\"  # Chat with **GPT-4**{: .color-primary}    <|{messages_to_data(saved_messages)}|table|show_all|width=100%|>    <br/>    <|{user_message}|input|multiline=True|lines_shown=2|label=Your Message|on_action=on_send_click|class_name=fullwidth|>    <|Send|button|on_action=on_send_click|>  \"\"\"    Gui(page).run() "}
{"text": "\"\"\"  Module Name: Frontend App with Taipy GUI  Author: Kenneth Leung  Last Modified: 25 Mar 2023  \"\"\"  # Launch app with the command in CLI: python main.py  from src.config import *  from src.functions import *  from pages.analysis_md import *  from pages.data_viewer_md import *  import taipy as tp  from taipy.gui import Gui, Icon, navigate    with open('config.yml') as f:      cfg = yaml.safe_load(f)    # =======================  #       Setup menu  # =======================  menu = [(\"Analysis\", Icon('assets/histogram_menu_2.png', 'Analysis')),          ('Data', Icon('assets/data_menu.png', 'Data'))]    page_markdown = \"\"\"  <|toggle|theme|>  <|menu|label=Menu|lov={menu}|on_action=menu_function|>  \"\"\"    pages = {\"/\":page_markdown,           \"Analysis\":analysis_page,           \"Data\":data_page}    def menu_function(state, var_name: str, fct: str, var_value: list):      # Change the value of the state.page variable in order to render the correct page      navigate(state, var_value[\"args\"][0])    # Run application  if __name__ == \"__main__\":      tp.Core().run()        # Create and execute scenario      scenario_selector = [(s.id, s.name) for s in tp.get_scenarios()]      scenario = tp.create_scenario(scenario_cfg, name=\"Default Scenario\")      selected_scenario = scenario.id      tp.submit(scenario)        df = scenario.pipeline_keyword_analysis.data_keywords_df.read()      df_keywords_count = scenario.pipeline_keyword_analysis.data_keywords_count.read()        Gui(pages=pages).run(title=\"Keyword Extraction and Analysis with KeyBERT and Taipy\",                            dark_mode=False,                            port=8020,                            use_reloader=True) "}
{"text": "\"\"\"  Module Name: Page Markdown Template (Analysis Page)  Author: Kenneth Leung  Last Modified: 8 Apr 2023  \"\"\"  import taipy as tp  from taipy.gui import notify  from src.config import scenario_cfg    import yaml  with open('config.yml') as f:      cfg = yaml.safe_load(f)    query = cfg['QUERY']  ngram_min = cfg['NGRAM_MIN']  ngram_max = cfg['NGRAM_MAX']  diversity_algo = cfg['DIVERSITY_ALGO']  diversity_algo_options = ['mmr', 'maxsum']  diversity = cfg['DIVERSITY']  top_n = cfg['TOP_N']  nr_candidates = cfg['NR_CANDIDATES']      # Input section of dashboard  input_page = \"\"\"  # Keyword Extraction and Analysis with KeyBERT and Taipy    <br/>    <|layout|columns=1 1 1 1 1 1 1|  <|{query}|input|label=Query Topic|>    <|{ngram_min}|number|label=Min N-gram|>    <|{ngram_max}|number|label=Max N-gram|>    <|{top_n}|number|label=Top n results|>    <|{diversity}|number|label=Diversity (for MMR)|>    <|{nr_candidates}|number|label=No. of Candidates (for MaxSum)|>    <|{diversity_algo}|selector|lov={diversity_algo_options}|dropdown|label=Diversity Algorithm|>    <|Update Analysis|button|on_action=submit_scenario|>  |>  <br/>   <br/>     <|{selected_scenario}|selector|lov={scenario_selector}|dropdown|label=Scenario|on_change=synchronize_gui_core|value_by_id|>     <|Save Scenario|button|on_action=create_scenario|>     <br/>    \"\"\"    # Chart types: https://docs.taipy.io/en/latest/manuals/gui/viselements/chart/  chart_properties = {\"type\":\"bar\",                      \"y\":\"keyword\",                      \"x\":\"count\",                      \"orientation\": \"h\",                      \"layout\": {                          \"xaxis\": {\"title\": \"Frequency Count\"},                          \"yaxis\": {\"title\": None},                          \"showlegend\": False, # Hide the legend                          \"title\": 'Keyword Frequency Bar Plot',                          \"margin\": {'pad': 0}                          }                  }    # Output section of dashboard  output_page = \"\"\"  <|layout|columns=1 1|gap=10px|  <|{df_keywords_count}|table|width=30|page_size=10|height=20|>    <|{df_keywords_count}|chart|properties={chart_properties}|height=20|>  |>    \"\"\"    # Combine layout segments  analysis_page = input_page + output_page      # ======= Scenario Setup =========  def create_scenario(state):      print(\"Creating scenario...\")      scenario = tp.create_scenario(scenario_cfg, name=f\"Scenario N {len(state.scenario_selector)} {state.query}\")      state.scenario_selector += [(scenario.id, scenario.name)]      state.selected_scenario = scenario.id      notify(state, 'success', 'Scenario created!')      submit_scenario(state)      def update_chart(state):      # Select the right scenario and pipeline      scenario = tp.get(state.selected_scenario)      # Update the chart based on this pipeline      state.df = scenario.pipeline_keyword_analysis.data_keywords_df.read()      state.df_keywords_count = scenario.pipeline_keyword_analysis.data_keywords_count.read()      def submit_scenario(state):       print(\"Submitting scenario...\")       notify(state, 'info', 'Submitting scenario...')       # Get the selected scenario: in this current step a single scenario is created then modified here.       scenario = tp.get(state.selected_scenario)         # Change the default parameters by writing in the datanodes       scenario.query.write(str(state.query))       scenario.ngram_max.write(int(state.ngram_max))       scenario.diversity_algo.write(str(state.diversity_algo))       scenario.diversity.write(float(state.diversity))       scenario.top_n.write(int(state.top_n))       scenario.nr_candidates.write(int(state.nr_candidates))         # Execute the pipelines/code       tp.submit(scenario)       notify(state, 'success', 'Execution finished!')       # Update the chart when we change the scenario       update_chart(state)      def synchronize_gui_core(state):      scenario = tp.get(state.selected_scenario)      # get the information of the selected scenario and display it on the GUI      state.query = scenario.query.read()      state.ngram_max = scenario.ngram_max.read()      state.diversity_algo = scenario.diversity_algo.read()      state.diversity = scenario.diversity.read()      state.top_n = scenario.top_n.read()      state.nr_candidates = scenario.nr_candidates.read()      update_chart(state) "}
{"text": "\"\"\"  Module Name: Page Markdown Template  Author: Kenneth Leung  Last Modified: 19 Mar 2023  \"\"\"    data_page = \"\"\"  # Extracted arXiv Abstracts    <|{df}|table|>    \"\"\""}
{"text": "\"\"\"  Module Name: Core Functions (Backend)  Author: Kenneth Leung  Last Modified: 19 Mar 2023  \"\"\"  import arxiv  import pandas as pd  import yaml  from keybert import KeyBERT      with open('config.yml') as f:      cfg = yaml.safe_load(f)    def extract_arxiv(query: str):      search = arxiv.Search(                  query=query,                  max_results=cfg['MAX_ABSTRACTS'], # Limit number of abstracts                  sort_by=arxiv.SortCriterion.SubmittedDate,                  sort_order=arxiv.SortOrder.Descending              )             # Returns arxiv object      return search      def save_in_dataframe(search):      df = pd.DataFrame([{'uid': result.entry_id.split('.')[-1],                          'title': result.title,                          'date_published': result.published,                          'abstract': result.summary} for result in search.results()])      return df      def preprocess_data(df: pd.DataFrame):      df['date_published'] = pd.to_datetime(df['date_published'])        # Create empty column to store keyword extraction output      df['keywords_and_scores'] = ''        # Create empty column to store top keywords      df['keywords'] = ''        return df      def run_keybert(df: pd.DataFrame, ngram_min: int, ngram_max: int, diversity_algo: str, top_n: int, diversity: float, nr_candidates: int):      kw_model = KeyBERT(model='all-MiniLM-L6-v2')      use_mmr = diversity_algo.lower() == 'mmr'      use_maxsum = diversity_algo.lower() == 'maxsum'            for i, row in df.iterrows():          abstract_text = row['abstract']          kw_output = kw_model.extract_keywords(abstract_text,                                                keyphrase_ngram_range=(ngram_min, ngram_max),                                                stop_words='english',                                                use_mmr=use_mmr,                                                use_maxsum=use_maxsum,                                                top_n=top_n,                                                diversity=diversity,                                                nr_candidates=nr_candidates)          df.at[i, 'keywords_and_scores'] = kw_output          df.at[i, 'keywords'] = [pair[0] for pair in kw_output]      return df      def get_keyword_value_counts(df):      keywords_count = pd.Series(df['keywords'].explode()).value_counts().reset_index()      keywords_count.columns = ['keyword', 'count']        return keywords_count "}
{"text": "\"\"\"  Module Name: Taipy Configurations  Author: Kenneth Leung  Last Modified: 19 Mar 2023  \"\"\"    import yaml  from taipy import Config, Scope  from src.functions import *    with open('config.yml') as f:      cfg = yaml.safe_load(f)    # ====================  #   Input Data Nodes  # ====================  # To place input values as DataNodeConfig objects  data_query_cfg = Config.configure_data_node(id='query', default_data=cfg['QUERY'])  data_ngram_min_cfg = Config.configure_data_node(id='ngram_min', default_data=cfg['NGRAM_MIN'])  data_ngram_max_cfg = Config.configure_data_node(id='ngram_max', default_data=cfg['NGRAM_MAX'])  data_diversity_algo_cfg = Config.configure_data_node(id='diversity_algo', default_data=cfg['DIVERSITY_ALGO'])  data_top_n_cfg = Config.configure_data_node(id='top_n', default_data=cfg['TOP_N'])  data_diversity_cfg = Config.configure_data_node(id='diversity', default_data=cfg['DIVERSITY'])  data_nr_candidates_cfg = Config.configure_data_node(id='nr_candidates', default_data=cfg['NR_CANDIDATES'])    # ===================  #   Key Data Nodes  # ===================  data_arxiv_search_cfg = Config.configure_data_node(id='data_arxiv_search')  data_raw_df_cfg = Config.configure_data_node(id='data_raw_df')  data_processed_df_cfg = Config.configure_data_node(id='data_processed_df')  data_keywords_df_cfg = Config.configure_data_node(id='data_keywords_df')  data_keywords_count_cfg = Config.configure_data_node(id='data_keywords_count')    # =================  #      Tasks  # =================  task_arxiv_extraction_cfg = Config.configure_task(id=\"task_arxiv_extraction\",                                                    function=extract_arxiv,                                                    input=data_query_cfg,                                                    output=data_arxiv_search_cfg,                                                    skippable=True)    task_save_in_df_cfg = Config.configure_task(id=\"task_save_in_df\",                                              function=save_in_dataframe,                                              input=data_arxiv_search_cfg,                                              output=data_raw_df_cfg,                                              skippable=True)    task_process_data_cfg = Config.configure_task(id='task_process_data',                                                function=preprocess_data,                                                input=data_raw_df_cfg,                                                output=data_processed_df_cfg,                                                skippable=True)    task_extract_keywords_cfg = Config.configure_task(id='task_extract_keywords',                                                    function=run_keybert,                                                    input=[data_processed_df_cfg,                                                            data_ngram_min_cfg,                                                           data_ngram_max_cfg,                                                            data_diversity_algo_cfg,                                                            data_top_n_cfg,                                                           data_diversity_cfg,                                                            data_nr_candidates_cfg],                                                    output=data_keywords_df_cfg)    task_get_kw_count_cfg = Config.configure_task(id='task_count_keywords',                                                    function=get_keyword_value_counts,                                                    input=data_keywords_df_cfg,                                                    output=data_keywords_count_cfg)      # =================  #     Pipelines  # =================  pipeline_data_prep_cfg = Config.configure_pipeline(id='pipeline_data_prep',                                                     task_configs=[task_arxiv_extraction_cfg,                                                                   task_save_in_df_cfg,                                                                   task_process_data_cfg,                                                                   ])    pipeline_keyword_analysis_cfg = Config.configure_pipeline(id='pipeline_keyword_analysis',                                                            task_configs=[task_extract_keywords_cfg,                                                                          task_get_kw_count_cfg                                                                          ])    # =============  #   Scenario   # =============  scenario_cfg = Config.configure_scenario(id=\"scenario\",                                            pipeline_configs=[pipeline_data_prep_cfg,                                                              pipeline_keyword_analysis_cfg                                                             ]) "}
{"text": ""}
{"text": "from taipy.gui import Gui  from pages import *      pages = {      \"/\": root_page,      \"pages\": pages  }      if __name__ == \"__main__\":        gui = Gui(pages=pages)      gui.run(title=\"ui\") "}
{"text": "from .root import root_page  from .pages.pages import pages "}
{"text": "\"\"\"  \"\"\"    from taipy.gui import Markdown    root_page = Markdown(\"pages/root.md\") "}
{"text": "\"\"\"  <|{value}|text|format=%.2f|>    \"\"\"    from taipy.gui import Markdown    pages = Markdown(\"pages/pages/pages.md\") "}
{"text": "import random    # Define a dictionary to store the year-wise and month-wise electricity usage  electricity_usage = {}    months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']    # For each year and each month, generate a random number between 1000 and 5000 to simulate the electricity usage for that month  for year in range(1, 6):      electricity_usage[year] = {}      for month in months:          electricity_usage[year][month] = random.randint(1000, 5000)    import csv  # Open a new CSV file in write mode  with open('electricity_usage.csv', 'w', newline='') as file:      writer = csv.writer(file)        # Write the header row      writer.writerow(['YearMonth', 'Usage'])        # Iterate over the years from 2001 to 2010, and for each month, write a row to the CSV file      for year in range(2001, 2011):          for month in range(1, 13):              usage = random.randint(1000, 5000)              writer.writerow([f'{year}/{month}', usage])"}
{"text": "from taipy.gui import Gui  import taipy as tp  import pandas as pd  import os      section_1 = \"\"\"  ## Power Consumption Dashboard  <|{dataset}|chart|x=YearMonth|y[1]=Usage|color=blue|>  \"\"\"    dataset = pd.read_csv(\"data.csv\")    rest = tp.Rest()  gui = Gui(page=section_1)    tp.run(      rest=rest,      gui=gui,      title=\"Taipy Dashboard\",      host='0.0.0.0',      port=os.environ.get('PORT', '5000'),      debug=False,  )      "}
{"text": "\"\"\"  A multi-page Taipy application, which includes 3 pages:  - A rootpage which is shared by other pages.  - Two pages named page_1 and page_2.    Please refer to https://docs.taipy.io/en/latest/manuals/gui/pages for more details.  \"\"\"    from pages import data_viz, scenario_page, performance  from pages.root import *    from config.config import *    from taipy.gui import Gui  import taipy as tp      def on_change(state, var_name: str, var_value):      state['scenario'].on_change(state, var_name, var_value)      pages = {      \"/\": root_page,      \"data_viz\": data_viz,      \"scenario\": scenario_page,      \"performance\": performance  }      if __name__ == \"__main__\":      tp.Core().run()      gui = Gui(pages=pages)      gui.run(title=\"Taipy Application\") "}
{"text": "import datetime as dt  import pandas as pd    from taipy import Config, Scope, Frequency    from algos.algos import *    path_to_csv = \"data/dataset.csv\"    # Datanodes (3.1)  ## Input Data Nodes  initial_dataset_cfg = Config.configure_data_node(id=\"initial_dataset\",                                                   storage_type=\"csv\",                                                   path=path_to_csv,                                                   scope=Scope.GLOBAL)    # We assume the current day is the 26th of July 2021.  # This day can be changed to simulate multiple executions of scenarios on different days  day_cfg = Config.configure_data_node(id=\"day\", default_data=dt.datetime(2021, 7, 26))    n_predictions_cfg = Config.configure_data_node(id=\"n_predictions\", default_data=40)    max_capacity_cfg = Config.configure_data_node(id=\"max_capacity\", default_data=200)    ## Remaining Data Nodes  cleaned_dataset_cfg = Config.configure_data_node(id=\"cleaned_dataset\",                                                   scope=Scope.GLOBAL)    predictions_baseline_cfg = Config.configure_data_node(id=\"predictions_baseline\")  predictions_ml_cfg = Config.configure_data_node(id=\"predictions_ml\")    full_predictions_cfg = Config.configure_data_node(id=\"full_predictions\")    metrics_baseline_cfg = Config.configure_data_node(id=\"metrics_baseline\")  metrics_ml_cfg = Config.configure_data_node(id=\"metrics_ml\")    # Functions (3.2)    # Tasks (3.3)  clean_data_task_cfg = Config.configure_task(id=\"task_clean_data\",                                              function=clean_data,                                              input=initial_dataset_cfg,                                              output=cleaned_dataset_cfg,                                              skippable=True)    predict_baseline_task_cfg = Config.configure_task(id=\"predict_baseline\",                                                    function=predict_baseline,                                                    input=[cleaned_dataset_cfg, n_predictions_cfg, day_cfg,                                                           max_capacity_cfg],                                                    output=predictions_baseline_cfg)      # Create the task configuration of the predict_ml function.  ## We use the same input and ouput as the previous predict_baseline task but we change the funtion  predict_ml_task_cfg = Config.configure_task(id=\"task_predict_ml\",                                              function=predict_ml,                                              input=[cleaned_dataset_cfg,                                                     n_predictions_cfg, day_cfg,                                                     max_capacity_cfg],                                              output=predictions_ml_cfg)      metrics_baseline_task_cfg = Config.configure_task(id=\"task_metrics_baseline\",                                              function=compute_metrics,                                              input=[cleaned_dataset_cfg,                                                     predictions_baseline_cfg],                                              output=metrics_baseline_cfg)    metrics_ml_task_cfg = Config.configure_task(id=\"task_metrics_ml\",                                              function=compute_metrics,                                              input=[cleaned_dataset_cfg,                                                     predictions_ml_cfg],                                              output=metrics_ml_cfg)    full_predictions_task_cfg = Config.configure_task(id=\"task_full_predictions\",                                              function=create_predictions_dataset,                                              input=[predictions_baseline_cfg,                                                     predictions_ml_cfg,                                                    day_cfg,                                                    n_predictions_cfg,                                                    cleaned_dataset_cfg],                                              output=full_predictions_cfg)          # Configure our scenario which is our business problem.  scenario_cfg = Config.configure_scenario_from_tasks(id=\"scenario\",                                                      task_configs=[clean_data_task_cfg,                                                                    predict_baseline_task_cfg,                                                                    predict_ml_task_cfg,                                                                    metrics_baseline_task_cfg,                                                                    metrics_ml_task_cfg,                                                                    full_predictions_task_cfg],                                                      frequency=Frequency.WEEKLY)    Config.export('config/config.toml') "}
{"text": "# For the sake of clarity, we have used an AutoRegressive model rather than a pure ML model such as:  # Random Forest, Linear Regression, LSTM, etc     from statsmodels.tsa.ar_model import AutoReg  import pandas as pd  from sklearn.metrics import mean_squared_error, mean_absolute_error  import numpy as np  import datetime as dt    def clean_data(initial_dataset: pd.DataFrame):      print(\"     Cleaning data\")      # Convert the date column to datetime      initial_dataset['Date'] = pd.to_datetime(initial_dataset['Date'])      cleaned_dataset = initial_dataset.copy()      return cleaned_dataset      def predict_baseline(cleaned_dataset: pd.DataFrame, n_predictions: int, day: dt.datetime, max_capacity: int):      print(\"     Predicting baseline\")      # Select the train data      train_dataset = cleaned_dataset[cleaned_dataset['Date'] < day]        predictions = train_dataset['Value'][-n_predictions:].reset_index(drop=True)      predictions = predictions.apply(lambda x: min(x, max_capacity))      return predictions      # This is the function that will be used by the task  def predict_ml(cleaned_dataset: pd.DataFrame, n_predictions: int, day: dt.datetime, max_capacity: int):      print(\"     Predicting with ML\")      # Select the train data      train_dataset = cleaned_dataset[cleaned_dataset[\"Date\"] < day]        # Fit the AutoRegressive model      model = AutoReg(train_dataset[\"Value\"], lags=7).fit()        # Get the n_predictions forecasts      predictions = model.forecast(n_predictions).reset_index(drop=True)      predictions = predictions.apply(lambda x: min(x, max_capacity))      return predictions      def compute_metrics(historical_data, predicted_data):      historical_to_compare = historical_data[-len(predicted_data):]['Value']      rmse = mean_squared_error(historical_to_compare, predicted_data)      mae = mean_absolute_error(historical_to_compare, predicted_data)      return rmse, mae    def create_predictions_dataset(predictions_baseline, predictions_ml, day, n_predictions, cleaned_data):      print(\"Creating predictions dataset...\")        # Set arbitrarily the time window for the chart as 5 times the number of predictions      window = 5 * n_predictions        # Create the historical dataset that will be displayed      new_length = len(cleaned_data[cleaned_data[\"Date\"] < day]) + n_predictions      temp_df = cleaned_data[:new_length]      temp_df = temp_df[-window:].reset_index(drop=True)        # Create the series that will be used in the concat      historical_values = pd.Series(temp_df[\"Value\"], name=\"Historical values\")      predicted_values_ml = pd.Series([np.NaN] * len(temp_df), name=\"Predicted values ML\")      predicted_values_ml[-len(predictions_ml):] = predictions_ml       predicted_values_baseline = pd.Series([np.NaN] * len(temp_df), name=\"Predicted values Baseline\")      predicted_values_baseline[-len(predictions_baseline):] = predictions_baseline        # Create the predictions dataset      # Columns : [Date, Historical values, Predicted values]      predictions_dataset = pd.concat([temp_df[\"Date\"],                                      historical_values,                                      predicted_values_ml,                                      predicted_values_baseline], axis=1)            return predictions_dataset"}
{"text": "from .data_viz import data_viz  from .scenario import scenario_page  from .performance import performance  from .root import root_page "}
{"text": "\"\"\"  The rootpage of the application.  Page content is imported from the root.md file.    Please refer to https://docs.taipy.io/en/latest/manuals/gui/pages for more details.  \"\"\"    from taipy.gui import Markdown    root_page = Markdown(\"pages/root.md\") "}
{"text": "from .scenario import scenario_page "}
{"text": "\"\"\"  The second page of the application.  Page content is imported from the page_2.md file.    Please refer to https://docs.taipy.io/en/latest/manuals/gui/pages for more details.  \"\"\"    from taipy.gui import Markdown, notify  import datetime as dt  import pandas as pd      scenario = None  day = dt.datetime(2021, 7, 26)  n_predictions = 40  max_capacity = 200  predictions_dataset = {\"Date\":[0],                          \"Predicted values ML\":[0],                         \"Predicted values Baseline\":[0],                         \"Historical values\":[0]}        def save(state):      print(\"Saving scenario...\")      # Get the currently selected scenario        # Conversion to the right format      state_day = dt.datetime(state.day.year, state.day.month, state.day.day)        # Change the default parameters by writing in the Data Nodes      state.scenario.day.write(state_day)      state.scenario.n_predictions.write(int(state.n_predictions))      state.scenario.max_capacity.write(int(state.max_capacity))      notify(state, \"success\", \"Saved!\")          def on_change(state, var_name, var_value):      if var_name == \"scenario\" and var_value:          state.day = state.scenario.day.read()          state.n_predictions = state.scenario.n_predictions.read()          state.max_capacity = state.scenario.max_capacity.read()                    if state.scenario.full_predictions.is_ready_for_reading:              state.predictions_dataset = state.scenario.full_predictions.read()          else:              state.predictions_dataset = predictions_dataset        scenario_page = Markdown(\"pages/scenario/scenario.md\") "}
{"text": "from .data_viz import data_viz "}
{"text": "\"\"\"  The first page of the application.  Page content is imported from the page_1.md file.    Please refer to https://docs.taipy.io/en/latest/manuals/gui/pages for more details.  \"\"\"    from taipy.gui import Markdown  import pandas as pd    def get_data(path_to_csv: str):      # pandas.read_csv() returns a pd.DataFrame      dataset = pd.read_csv(path_to_csv)      dataset[\"Date\"] = pd.to_datetime(dataset[\"Date\"])      return dataset    # Read the dataframe  path_to_csv = \"data/dataset.csv\"  dataset = get_data(path_to_csv)    # Initial value  n_week = 10    # Select the week based on the slider value  dataset_week = dataset[dataset[\"Date\"].dt.isocalendar().week == n_week]    def on_slider(state):      state.dataset_week = dataset[dataset[\"Date\"].dt.isocalendar().week == state.n_week]      data_viz = Markdown(\"pages/data_viz/data_viz.md\") "}
{"text": "from .performance import performance "}
{"text": "from taipy.gui import Markdown    import pandas as pd  import taipy as tp    # Initial dataset for comparison  comparison_scenario = pd.DataFrame(columns=[\"Scenario Name\",                                              \"RMSE baseline\",                                              \"MAE baseline\",                                              \"RMSE ML\",                                              \"MAE ML\"])      # Selector for metrics  metric_selector = [\"RMSE\", \"MAE\"]  selected_metric = metric_selector[0]      def compare(state):      print(\"Comparing...\")        # Initialize lists for comparison      scenario_data = []        # Go through all the primary scenarios      all_scenarios = sorted(tp.get_primary_scenarios(), key=lambda x: x.creation_date.timestamp())        for scenario in all_scenarios:          rmse_baseline, mae_baseline = scenario.metrics_baseline.read()          rmse_ml, mae_ml = scenario.metrics_ml.read()              # Store scenario data in a dictionary          scenario_data.append({              \"Scenario Name\": scenario.name,              \"RMSE baseline\": rmse_baseline,              \"MAE baseline\": mae_baseline,              \"RMSE ML\": rmse_ml,              \"MAE ML\": mae_ml          })        # Create a DataFrame from the scenario_data list      state.comparison_scenario = pd.DataFrame(scenario_data)    performance = Markdown(\"pages/performance/performance.md\") "}
{"text": "# ################################################################################  # setup_generation.py  #   Prepares all files before running MkDocs to generate the complete  #   Taipy documentation set.  #  # This setup is performed by executing successive steps, depending on the  # topic (Reference Manual generation, JavaScript documentation integration  # within MkDocs...)  # ################################################################################    import os    from _setup_generation import run_setup    steps = None  # --------------------------------------------------------------------------------  # You may want to replace that 'step' initial value with a list of steps you  # want to run.  # i.e. say you want to run only the Reference Manual generation step.  # You could add the following code:  #   from _setup_generation.step_refman import RefManStep  #   steps = [RefManStep()]  # --------------------------------------------------------------------------------    # Assuming that this script is located in <taipy-doc>/tools  run_setup(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), steps) "}
{"text": "import os  import re  import logging    SITE_DIR = \"site\"    def to_unix(p):      return p.replace(\"\\\\\",\"/\")  # Assuming that this script is located in <taipy-doc>/tools  tools_dir = os.path.dirname(__file__)  site_path = os.path.join(os.path.dirname(tools_dir), SITE_DIR)  ref_site_path = to_unix(site_path)    logger = logging.getLogger(\"taipy-doc-checker\")  logging.basicConfig(level=logging.INFO)  logger.info(f\"Site: {site_path}\")  if not os.path.isdir(site_path):      logger.critical(\"Site does not exist. Please run 'mkdocs build' first.\")      exit(1)    A_RE = re.compile(r\"<a href=\\\"(.*?)\\\"\")  for root, _, file_list in os.walk(site_path):      this_dir = to_unix(root)      for f in file_list:          if f.endswith(\".html\"):              filename = to_unix(os.path.join(root, f))              ref_filename = filename[len(ref_site_path):]              with open(filename) as html_file:                  ref_root = to_unix(root)                  try:                      html_content = html_file.read()                      for anchor in A_RE.finditer(html_content):                          href = anchor.group(1)                          if href.startswith(\"/en/develop/\"):                              href = href[12:]                          if href != \".\" and href != \"..\" and not href.startswith(\"http\") and not href.startswith(\"mailto\"):                              if href.startswith(\"#\"):                                  id=href[1:]                                  if not id in html_content:                                      logger.error(f\"No id {id} in {ref_filename}\")                              else:                                  if href.endswith(\"/\"):                                      target = to_unix(os.path.join(ref_root, href))[:-1]                                      if not os.path.isdir(target) or not os.path.isfile(target + \"/index.html\"):                                          logger.error(f\"Bad xref '{href}' in {ref_filename}\")                  except Exception as e:                      logger.error(f\"Couldn't read HTML file {filename}\")                      raise e "}
{"text": "\"\"\"  Check that parameters' documentation have a uniform format.    - `<param_name>`: [The |A |An ]*.  \"\"\"  import sys    COMMENTS_CAN_START_WITH = ' The ', ' If ', ' An ', ' A ', ' TODO '    filename = sys.argv[1]    for line in open(filename).readlines():      if line.replace(' ', '').startswith('-`') and ':' in line:          try:              variable, comment = line.split(':', maxsplit=1)                assert variable.endswith(' ') is False              # Too early for this              # ------------------              # assert any(comment.startswith(x) for x in COMMENTS_CAN_START_WITH)              # if not comment.startswith(\" TODO \"):              #     assert comment[-1] == '.' or comment[-2] == '.'          except Exception as _:              print(f\"Error in file '{filename}': '{line}'\")              exit(1) "}
{"text": "from .setup import run_setup "}
{"text": "# ################################################################################  # Taipy GUI Extension Reference Manual generation setup step.  #  # The Reference Manual pages for the Taipy GUI JavaScript extension module  # is generated using the typedoc tools, directly from the JavaScript  # source files.  # ################################################################################  from .setup import Setup, SetupStep  import os  import re  import shutil  import subprocess      class GuiExtRefManStep(SetupStep):      def get_id(self) -> str:          return \"guiext\"        def get_description(self) -> str:          return \"Generating the GUI Extension API documentation\"        def enter(self, setup: Setup):          self.GUI_EXT_REF_DIR_PATH = setup.manuals_dir + \"/reference_guiext\"          if os.path.exists(self.GUI_EXT_REF_DIR_PATH):              shutil.rmtree(self.GUI_EXT_REF_DIR_PATH)          npm_path = shutil.which(\"npm\")          if npm_path:              if \" \" in npm_path:                  npm_path = f\"\\\"{npm_path}\\\"\"              try:                  subprocess.run(f\"{npm_path} --version\", shell=True, capture_output=True)              except OSError:                  print(f\"WARNING: Couldn't run npm, ignoring this step.\", flush=True)                  npm_path = None          self.npm_path = npm_path        def setup(self, setup: Setup) -> None:          if self.npm_path:              saved_cwd = os.getcwd()              gui_path = os.path.join(setup.root_dir, \"gui\")              os.chdir(gui_path)              print(f\"... Installing node modules...\", flush=True)              subprocess.run(f\"{self.npm_path} run inst\", shell=True)              print(f\"... Generating documentation...\", flush=True)              subprocess.run(f\"{self.npm_path} run mkdocs\", shell=True)              # Process and copy files to docs/manuals              os.mkdir(self.GUI_EXT_REF_DIR_PATH)              dst_dir = os.path.abspath(self.GUI_EXT_REF_DIR_PATH)              src_dir = os.path.abspath(os.path.join(gui_path, \"reference_guiext\"))              JS_EXT_RE = re.compile(r\"^(.*?)(\\n#.*?\\n)\", re.MULTILINE | re.DOTALL)              for root, dirs, files in os.walk(src_dir):                  for file in files:                      file_content = None                      path_name = os.path.join(root, file)                      with open(path_name) as input:                          file_content = input.read()                      match = JS_EXT_RE.search(file_content)                      if match:                          file_content = match.group(2) + match.group(1) + file_content[match.end():]                      path_name = path_name.replace(src_dir, dst_dir)                      with open(path_name, \"w\") as output:                          output.write(file_content)                  for dir in dirs:                      os.mkdir(os.path.join(dst_dir, dir))              os.chdir(saved_cwd) "}
{"text": "from abc import ABC, abstractmethod  from datetime import datetime  import re  import shutil  import sys  from typing import List      class Setup(ABC):      ROOT_PACKAGE = \"taipy\"        ENTERPRISE_BANNER = \"\"\"!!! warning \"Available in Taipy Enterprise edition\"        This section is relevant only to the Enterprise edition of Taipy.    \"\"\"        def __init__(self, root_dir: str, steps: List[\"SetupStep\"]):          self.root_dir = root_dir.replace(\"\\\\\", \"/\")          self.docs_dir = self.root_dir + \"/docs\"          self.manuals_dir = self.docs_dir + \"/manuals\"          self.tools_dir = self.root_dir + \"/tools\"          # self.requested_steps, if not None, indicates which steps should be performed.          self.requested_steps = None          if len(sys.argv) > 1:              self.requested_steps = []              for step_id in sys.argv[1:]:                  if not [step for step in steps if step_id == step.get_id()]:                      raise SystemError(f\"FATAL - '{step_id}' is not a valid step identifier\")              for step in steps:                  if step.get_id() in sys.argv[1:]:                      self.requested_steps.append(step)          self.mkdocs_yml_template_content = None          self.MKDOCS_YML_PATH = self.root_dir + \"/mkdocs.yml\"          self.MKDOCS_YML_TEMPLATE_PATH = self.MKDOCS_YML_PATH + \"_template\"          with open(self.MKDOCS_YML_TEMPLATE_PATH) as mkdocs_yml_file:              self.mkdocs_yml_template_content = mkdocs_yml_file.read()          if not self.mkdocs_yml_template_content:              raise SystemError(                  \"FATAL - Could not read MkDocs template configuration file at {MKDOCS_YML_TEMPLATE_PATH}\"              )          self.steps = []          for step in steps:              if not self.requested_steps or step in self.requested_steps:                  self.steps.append(step)                  step.enter(self)              else:                  step.exit(self)        def setup(self):          n_steps = len(self.steps)          line = \"+\" + \"-\" * 60          for step_index, step in enumerate(self.steps):              description = step.get_description()              if description:                  description = f\": {description}\"              print(f\"{line}\\n| Step {step_index + 1}/{n_steps}{description}\\n{line}\", flush=True)              step.setup(self)        def exit(self):          for step in self.steps:              step.exit(self)          self.update_mkdocs_yaml_template(r\"\\[YEAR\\]\", f\"{str(datetime.now().year)}\")          with open(self.MKDOCS_YML_PATH, \"w\") as mkdocs_yml_file:              mkdocs_yml_file.write(self.mkdocs_yml_template_content)        # Utility function to update the MkDocs yml template file      def update_mkdocs_yaml_template(self, pattern: str, replacement: str):          # Retrieve and keep indendation          if pattern.startswith(r\"^\\s*\"):              pattern = r\"^(\\s*)\" + pattern[4:]              lines = replacement.split(\"\\n\")              if not lines[-1]:                  lines = lines[:-1]              replacement = \"\\n\".join(map(lambda s: r\"\\1\"+s, lines))+\"\\n\"            self.mkdocs_yml_template_content = re.sub(              pattern,              replacement if replacement else \"\",              self.mkdocs_yml_template_content,              flags=re.MULTILINE | re.DOTALL,          )        # Move the top package directory to 'tools' when generating the Reference      # Manual, or when using Taipy classes.      # MkDocs needs it at the root level so we will have to move it back.      def move_package_to_tools(self, package: str) -> None:          shutil.move(f\"{self.root_dir}/{package}\", f\"{self.tools_dir}/{package}\")        def move_package_to_root(self, package: str) -> None:          shutil.move(f\"{self.tools_dir}/{package}\", f\"{self.root_dir}/{package}\")      class SetupStep(ABC):        @abstractmethod      def get_id(self) -> str:          return \"\"        def get_description(self) -> str:          return \"\"        def enter(self, setup: Setup):          pass        def exit(self, setup: Setup):          \"\"\"Called after the step is executed.            Note that this member function is also called, before _enter()_,          if this step is skipped.          \"\"\"          pass        @abstractmethod      def setup(self, setup: Setup):          pass      def run_setup(root_dir: str, steps: List[SetupStep] = None):      if not steps:          from .step_viselements import VisElementsStep          from .step_refman import RefManStep          from .step_rest_refman import RestRefManStep          from .step_gui_ext_refman import GuiExtRefManStep          from .step_contributors import ContributorsStep            steps = [              VisElementsStep(),              RefManStep(),              RestRefManStep(),              GuiExtRefManStep(),              ContributorsStep()          ]      setup = Setup(root_dir, steps)      setup.setup()      setup.exit() "}
{"text": "import os  from typing import List      class GitContext(object):      \"\"\"Temporarily force GIT_TERMINAL_PROMPT to 0 for private repositories.\"\"\"      V = \"GIT_TERMINAL_PROMPT\"        def __init__(self, repo: str, private_repos: List[str]):          self.value = None          self.save_value = repo in private_repos        def __enter__(self):          if self.save_value:              self.value = os.environ.get(__class__.V, None)              os.environ[__class__.V] = \"0\"        def __exit__(self, exception_type, exception_value, traceback):          if self.save_value:              if self.value:                  os.environ[__class__.V] = self.value              else:                  del os.environ[__class__.V] "}
{"text": "from .git_context import GitContext  from .cli import CLI  from .utils import read_doc_version_from_mkdocs_yml_template_file "}
{"text": "import argparse      class CLI():      DESCRIPTION = \"\"\"\\  Locally copies the source code of Taipy from different places  in order to allow the generation of the documentation set.  After this script has run, you can run 'mkdocs serve'.  \"\"\"      ARG_N_HELP = \"Prevents the source repository update (local only).\"      ARG_C_HELP = \"Only checks if the fetch can be performed then exits.\"      ARG_VERSION_HELP_1 = \"\"\"\\  The version for the whole doc set, or specific repositories.  This can be 'local', 'develop' or a valid version number.  It can be prefixed with '<repository>:', then the version applies  only to that repository. If that prefix is not present, the version  applies to all repositories.  Valid repository names are:  \"\"\"      ARG_VERSION_HELP_2 = \"\"\"  Note that each <version> arguments may overwrite the previous ones.  i.e.:    '2.0 core:1.0' will set all versions to 2.0 except for      the 'core' repository.    'core:1.0 2.0' will set version 2.0 for all repositories.  If <version> is 'local', the code is retrieved from a directory called  'taipy-<repository-name>', above the current directory.  If <version> is 'develop', the develop branch for the indicated repository  is used.  If <version> is '<Major>.<Minor>', the corresponding branch is used.  If <version> contains an additional '.<Patch>[.<More>]' fragment, then the  corresponding tag is extracted from the '<Major>.<Minor>' branch for that  repository.  If any version is not 'local', then the 'git' command must be accessible.    The default behaviour is to use a local version for all repositories.  \"\"\"        def __init__(self, script_name, repos):          self.parser = argparse.ArgumentParser(prog=\"python \" + script_name,                                                formatter_class=argparse.RawTextHelpFormatter,                                                description=self.DESCRIPTION)          self.parser.add_argument(\"-n\", \"--no_pull\", action='store_true',                                   help=self.ARG_N_HELP)          self.parser.add_argument(\"-c\", \"--check\", action='store_true',                                   help=self.ARG_C_HELP)          self.parser.add_argument('version', nargs='*',                                   help=self.ARG_VERSION_HELP_1 +                                        \"\\n\".join([\"  - \" + p for p in repos]) +                                        self.ARG_VERSION_HELP_2)        def get_args(self):          return self.parser.parse_args() "}
{"text": "import os  import re      def read_doc_version_from_mkdocs_yml_template_file(root_dir):      \"\"\"Read version from mkdocs.yml template\"\"\"      mkdocs_yml_template = None      mkdocs_yml_template_path = os.path.join(root_dir, \"mkdocs.yml_template\")      with open(mkdocs_yml_template_path, \"r\") as mkdocs_file:          mkdocs_yml_template = mkdocs_file.read()      if mkdocs_yml_template is None:          raise IOError(f\"Couldn't open '{mkdocs_yml_template_path}'\")      mkdocs_yml_version = re.search(r\"site_url:\\s*https://docs\\.taipy\\.io/en/(develop|release-(\\d\\.\\d))$\",                                     mkdocs_yml_template, re.MULTILINE)      if mkdocs_yml_version is None:          raise ValueError(              f\"'{mkdocs_yml_template_path}' has an invalid site_url value. This must be 'develop' or 'release-[M].[m]'.\")      return mkdocs_yml_version.group(2) if mkdocs_yml_version.group(2) else mkdocs_yml_version.group(1) "}
{"text": "from datetime import datetime    import pandas as pd    from taipy import Config, Frequency, Scope      def write_orders_plan(data: pd.DataFrame):      insert_data = data[[\"date\", \"product_id\", \"number_of_products\"]].to_dict(\"records\")      return [\"DELETE FROM orders\", (\"INSERT INTO orders VALUES (:date, :product_id, :number_of_products)\", insert_data)]      def train(sales_history: pd.DataFrame):      print(\"Running training\")      return \"TRAINED_MODEL\"      def predict(model, current_month):      print(\"Running predicting\")      return \"SALES_PREDICTIONS\"      def plan(sales_predictions, capacity):      print(\"Running planning\")      return \"PRODUCTION_ORDERS\"      def compare(previous_month_prediction, current_month_prediction):      print(\"Comparing previous month and current month sale predictions\")      return \"COMPARISON_RESULT\"      # Configure all six data nodes  sales_history_cfg = Config.configure_csv_data_node(      id=\"sales_history\", scope=Scope.GLOBAL, default_path=\"path/sales.csv\"  )  trained_model_cfg = Config.configure_data_node(id=\"trained_model\", scope=Scope.CYCLE)  current_month_cfg = Config.configure_data_node(id=\"current_month\", scope=Scope.CYCLE, default_data=datetime(2020, 1, 1))  sales_predictions_cfg = Config.configure_data_node(id=\"sales_predictions\", scope=Scope.CYCLE)  capacity_cfg = Config.configure_data_node(id=\"capacity\")  orders_cfg = Config.configure_sql_data_node(      id=\"orders\",      db_username=\"admin\",      db_password=\"ENV[PWD]\",      db_name=\"production_planning\",      db_engine=\"mssql\",      read_query=\"SELECT orders.ID, orders.date, products.price, orders.number_of_products FROM orders INNER JOIN products ON orders.product_id=products.ID\",      write_query_builder=write_orders_plan,      db_driver=\"ODBC Driver 17 for SQL Server\",  )    # Configure the three tasks  training_cfg = Config.configure_task(\"training\", train, sales_history_cfg, [trained_model_cfg])  predicting_cfg = Config.configure_task(      id=\"predicting\", function=predict, input=[trained_model_cfg, current_month_cfg], output=sales_predictions_cfg  )  planning_cfg = Config.configure_task(      id=\"planning\", function=plan, input=[sales_predictions_cfg, capacity_cfg], output=[orders_cfg]  )    # Configure the scenario  monthly_scenario_cfg = Config.configure_scenario(      id=\"scenario_configuration\",      task_configs=[training_cfg, predicting_cfg, planning_cfg],      frequency=Frequency.MONTHLY,      comparators={sales_predictions_cfg.id: compare},      sequences={\"sales\": [training_cfg, predicting_cfg], \"production\": [planning_cfg]},  ) "}
{"text": "from taipy import Config  from datetime import datetime    class DailyMinTemp:      def __init__(self, Date : datetime=None, Temp : float=None):          self.Date = Date          self.Temp = Temp        def encode(self):          return {              \"date\": self.Date.isoformat(),              \"temperature\": self.Temp,          }        @classmethod      def decode(cls, data):          return cls(              datetime.fromisoformat(data[\"date\"]),              data[\"temperature\"],          )    historical_data_cfg = Config.configure_mongo_collection_data_node(      id=\"historical_data\",      db_username=\"admin\",      db_password=\"pa$$w0rd\",      db_name=\"taipy\",      collection_name=\"historical_data_set\",      custom_document=DailyMinTemp,  ) "}
{"text": "from datetime import timedelta  from taipy import Config, Scope    date_cfg = Config.configure_data_node(      id=\"date_cfg\",      description=\"The current date of the scenario\",  )    model_cfg = Config.configure_data_node(      id=\"model_cfg\",      scope=Scope.CYCLE,      storage_type=\"pickle\",      validity_period=timedelta(days=2),      description=\"Trained model shared by all scenarios\",      code=54,  ) "}
{"text": "from taipy import Config    historical_data_cfg = Config.configure_mongo_collection_data_node(      id=\"historical_data\",      db_username=\"admin\",      db_password=\"pa$$w0rd\",      db_name=\"taipy\",      collection_name=\"historical_data_set\",  ) "}
{"text": "import csv  from typing import List, Iterator  from taipy import Config      def read_csv(path: str, delimiter: str = \",\") -> Iterator:      with open(path, newline=' ') as csvfile:          data = csv.reader(csvfile, delimiter=delimiter)      return data      def write_csv(data: List[str], path: str, delimiter: str = \",\") -> None:      headers = [\"country_code\", \"country\"]      with open(path, 'w') as csvfile:          writer = csv.writer(csvfile, delimiter=delimiter)          writer.writerow(headers)          for row in data:              writer.writerow(row)      csv_country_data_cfg = Config.configure_generic_data_node(      id=\"csv_country_data\",      read_fct=read_csv,      write_fct=write_csv,      read_fct_args=[\"../path/data.csv\", \";\"],      write_fct_args=[\"../path/data.csv\", \";\"]) "}
{"text": "from taipy import Config, Scope    Config.set_default_data_node_configuration(      storage_type=\"sql_table\",      db_username=\"username\",      db_password=\"p4$$w0rD\",      db_name=\"sale_db\",      db_engine=\"mssql\",      table_name=\"products\",      db_host=\"localhost\",      db_port=1437,      db_driver=\"ODBC Driver 17 for SQL Server\",      db_extra_args={\"TrustServerCertificate\": \"yes\"},      scope=Scope.GLOBAL,  )    products_data_cfg = Config.configure_data_node(id=\"products_data\")  users_data_cfg = Config.configure_data_node(id=\"users_data\", table_name=\"users\")  retail_data_cfg = Config.configure_data_node(id=\"retail_data\", storage_type=\"sql_table\", table_name=\"retail_data\")  wholesale_data_cfg = Config.configure_sql_table_data_node(id=\"wholesale_data\", table_name=\"wholesale_data\")    forecast_data_cfg = Config.configure_data_node(id=\"forecast_data\", storage_type=\"csv\", default_path=\"forecast.csv\") "}
{"text": "from datetime import datetime as dt  import pandas as pd  from taipy import Config      def read_csv(path: str) -> pd.DataFrame:      # reading a csv file, define some column types and parse a string into datetime      custom_parser = lambda x: dt.strptime(x, \"%Y %m %d %H:%M:%S\")      data = pd.read_csv(          path,          parse_dates=['date'],          date_parser=custom_parser,          dtype={              \"name\": str,              \"grade\": int          }      )      return data      def write_csv(data: pd.DataFrame, path: str) -> None:      # dropping not a number values before writing      data.dropna().to_csv(path)      student_data = Config.configure_generic_data_node(      id=\"student_data\",      read_fct=read_csv,      write_fct=write_csv,      read_fct_args=[\"../path/data.csv\"],      write_fct_args=[\"../path/data.csv\"]) "}
{"text": "from taipy import Config    sales_history_cfg = Config.configure_sql_table_data_node(      id=\"sales_history\",      db_username=\"admin\",      db_password=\"password\",      db_name=\"taipy\",      db_engine=\"mssql\",      table_name=\"sales\",      db_driver=\"ODBC Driver 17 for SQL Server\",      db_extra_args={\"TrustServerCertificate\": \"yes\"},  ) "}
{"text": "from taipy import Config  import pandas as pd    def write_query_builder(data: pd.DataFrame):      insert_data = data[[\"date\", \"nb_sales\"]].to_dict(\"records\")      return [          \"DELETE FROM sales\",          (\"INSERT INTO sales VALUES (:date, :nb_sales)\", insert_data)      ]    sales_history_cfg = Config.configure_sql_data_node(      id=\"sales_history\",      db_name=\"taipy\",      db_engine=\"sqlite\",      read_query=\"SELECT * from sales\",      write_query_builder=write_query_builder,      sqlite_folder_path=\"database\",      sqlite_file_extension=\".sqlite3\",  ) "}
{"text": "from taipy import Config    class SaleRow:      date: str      nb_sales: int    hist_temp_cfg = Config.configure_excel_data_node(      id=\"historical_temperature\",      default_path=\"path/hist_temp.xlsx\",      exposed_type=\"numpy\")    hist_log_cfg = Config.configure_excel_data_node(      id=\"log_history\",      default_path=\"path/hist_log.xlsx\",      exposed_type=\"modin\")    sales_history_cfg = Config.configure_excel_data_node(      id=\"sales_history\",      default_path=\"path/sales.xlsx\",      sheet_name=[\"January\", \"February\"],      exposed_type=SaleRow) "}
{"text": "from taipy import Config  from datetime import datetime    date_cfg = Config.configure_in_memory_data_node(      id=\"date\",      default_data=datetime(2022, 1, 25)) "}
{"text": "from taipy import Config    sales_history_cfg = Config.configure_sql_table_data_node(      id=\"sales_history\",      db_name=\"taipy\",      db_engine=\"sqlite\",      table_name=\"sales\",      sqlite_folder_path=\"database\",      sqlite_file_extension=\".sqlite3\",  ) "}
{"text": "from taipy import Config    data_node_cfg = Config.configure_data_node(id=\"data_node_cfg\") "}
{"text": "from taipy import Config    class SaleRow:      date: str      nb_sales: int    temp_cfg = Config.configure_csv_data_node(      id=\"historical_temperature\",      default_path=\"path/hist_temp.csv\",      has_header=True,      exposed_type=\"numpy\")    log_cfg = Config.configure_csv_data_node(      id=\"log_history\",      default_path=\"path/hist_log.csv\",      exposed_type=\"modin\")    sales_history_cfg = Config.configure_csv_data_node(      id=\"sales_history\",      default_path=\"path/sales.csv\",      exposed_type=SaleRow) "}
{"text": "from taipy import Config    temp_cfg = Config.configure_parquet_data_node(      id=\"historical_temperature\",      default_path=\"path/hist_temp.parquet\") "}
{"text": "from taipy import Config  import pandas as pd    def write_query_builder(data: pd.DataFrame):      insert_data = data[[\"date\", \"nb_sales\"]].to_dict(\"records\")      return [          \"DELETE FROM sales\",          (\"INSERT INTO sales VALUES (:date, :nb_sales)\", insert_data)      ]    sales_history_cfg = Config.configure_sql_data_node(      id=\"sales_history\",      db_username=\"admin\",      db_password=\"password\",      db_name=\"taipy\",      db_engine=\"mssql\",      read_query=\"SELECT * from sales\",      write_query_builder=write_query_builder,      db_driver=\"ODBC Driver 17 for SQL Server\",      db_extra_args={\"TrustServerCertificate\": \"yes\"},  ) "}
{"text": "from taipy import Config  import json      class SaleRow:      date: str      nb_sales: int      class SaleRowEncoder(json.JSONEncoder):      def default(self, obj):          if isinstance(obj, SaleRow):              return {                  '__type__': \"SaleRow\",                  'date': obj.date,                  'nb_sales': obj.nb_sales}          return json.JSONEncoder.default(self, obj)      class SaleRowDecoder(json.JSONDecoder):      def __init__(self, *args, **kwargs):          json.JSONDecoder.__init__(self,                                    object_hook=self.object_hook,                                    *args,                                    **kwargs)        def object_hook(self, d):          if d.get('__type__') == \"SaleRow\":              return SaleRow(date=d['date'], nb_sales=d['nb_sales'])          return d      sales_history_cfg = Config.configure_json_data_node(      id=\"sales_history\",      path=\"path/sales.json\",      encoder=SaleRowEncoder,      decoder=SaleRowDecoder) "}
{"text": "from taipy import Config    read_kwargs = {\"filters\": [(\"log_level\", \"in\", {\"ERROR\", \"CRITICAL\"})]}  write_kwargs = {\"partition_cols\": [\"log_level\"], \"compression\": None}    log_cfg = Config.configure_parquet_data_node(      id=\"log_history\",      default_path=\"path/hist_log.parquet\",      engine=\"pyarrow\", # default      compression=\"snappy\", # default, but overridden by the key in write_kwargs      exposed_type=\"modin\",      read_kwargs=read_kwargs,      write_kwargs=write_kwargs) "}
{"text": "from taipy import Config    hist_temp_cfg = Config.configure_json_data_node(      id=\"historical_temperature\",      default_path=\"path/hist_temp.json\",  ) "}
{"text": "from taipy import Config      def read_text(path: str) -> str:      with open(path, 'r') as text_reader:          data = text_reader.read()      return data      def write_text(data: str, path: str) -> None:      with open(path, 'w') as text_writer:          text_writer.write(data)      historical_data_cfg = Config.configure_generic_data_node(      id=\"historical_data\",      read_fct=read_text,      write_fct=write_text,      read_fct_args=[\"../path/data.txt\"],      write_fct_args=[\"../path/data.txt\"]) "}
{"text": "from taipy import Config, Scope    products_data_cfg = Config.configure_sql_table_data_node(      id=\"products_data\",      db_username=\"foo\",      db_password=\"bar\",      db_name=\"db\",      db_engine=\"mssql\",      db_host=\"localhost\",      db_port=1437,      db_driver=\"ODBC Driver 17 for SQL Server\",      db_extra_args={\"TrustServerCertificate\": \"yes\"},      table_name=\"products\",  )    users_data_cfg = Config.configure_data_node_from(      source_configuration=products_data_cfg,      id=\"users_data\",      scope=Scope.GLOBAL,      table_name=\"users\",  )    retail_data_cfg = Config.configure_data_node_from(      source_configuration=products_data_cfg,      id=\"retail_data\",      table_name=\"retail_data\",  )    wholesale_data_cfg = Config.configure_data_node_from(      source_configuration=products_data_cfg,      id=\"wholesale_data\",      table_name=\"wholesale_data\",  ) "}
{"text": "from taipy import Config  from datetime import datetime    date_cfg = Config.configure_pickle_data_node(      id=\"date_cfg\",      default_data=datetime(2022, 1, 25))    model_cfg = Config.configure_pickle_data_node(      id=\"model_cfg\",      default_path=\"path/to/my/model.p\",      description=\"The trained model\") "}
{"text": "from taipy import Config      def multiply_and_add(nb1, nb2):      return nb1 * nb2, nb1 + nb2      nb_1_cfg = Config.configure_data_node(\"nb_1\", default_data=21)  nb_2_cfg = Config.configure_data_node(\"nb_2\", default_data=2)    multiplication_cfg = Config.configure_data_node(\"multiplication\")  addition_cfg = Config.configure_data_node(\"addition\")    task_cfg = Config.configure_task(\"foo\",                                   multiply_and_add,                                   [nb_1_cfg, nb_2_cfg],                                   [multiplication_cfg, addition_cfg]) "}
{"text": "from taipy import Config      def double(nb):      return nb * 2      input_data_node_cfg = Config.configure_data_node(\"input\",                                                   default_data=21)  output_data_node_cfg = Config.configure_data_node(\"output\")    double_task_cfg = Config.configure_task(\"double_task\",                                          double,                                          input_data_node_cfg,                                          output_data_node_cfg,                                          skippable=True) "}
{"text": "import taipy as tp  from taipy import Config, Core    ################################################################  #                  Configure your application                  #  ################################################################      def build_message(name):      return f\"Hello {name}!\"      # A first data node configuration represents a name  name_data_node_cfg = Config.configure_data_node(id=\"input_name\")  # A second data node configuration represents the message to print  message_data_node_cfg = Config.configure_data_node(id=\"message\")  # The task represents the build_message function  build_msg_task_cfg = Config.configure_task(\"build_msg\", build_message, name_data_node_cfg, message_data_node_cfg)  # The scenario represent the whole execution graph  scenario_cfg = Config.configure_scenario(\"scenario\", task_configs=[build_msg_task_cfg])    if __name__ == \"__main__\":      ################################################################      #            Instantiate the Core service and run it           #      ################################################################      Core().run()        ################################################################      #               Manage your scenarios and data nodes           #      ################################################################      zinedine_scenario = tp.create_scenario(scenario_cfg)      kylian_scenario = tp.create_scenario(scenario_cfg)        zinedine_scenario.input_name.write(\"Zinedine\")      zinedine_scenario.submit()      print(zinedine_scenario.message.read())        kylian_scenario.input_name.write(\"Kylian Mbappe\")      kylian_scenario.submit()      print(kylian_scenario.message.read()) "}
{"text": "import taipy as tp  from taipy import Config, Scope      def example_algorithm(entry: str):      # does nothing!      return entry      input_cfg = Config.configure_data_node(\"input\", path=\"input.pkl\", scope=Scope.GLOBAL, default_data=\"A string\")  output_cfg = Config.configure_data_node(\"output\", path=\"output.pkl\", scope=Scope.GLOBAL)  task_cfg = Config.configure_task(\"example_algorithm\", example_algorithm, input_cfg, output_cfg, skippable=True)  scenario_cfg = Config.configure_scenario(\"my_scenario\", [task_cfg])    if __name__ == \"__main__\":      tp.Core().run()      tp.create_scenario(scenario_cfg)      print(f\"Number of scenarios: {len(tp.get_scenarios())}\") "}
{"text": "import taipy as tp  from taipy import Config      def example_algorithm(entry: str):      # does nothing!      return entry      input_cfg = Config.configure_data_node(\"input\", default_data=\"a_string\")  output_cfg = Config.configure_data_node(\"output\", description=\"What a description\")  task_cfg = Config.configure_task(\"example_algorithm\", example_algorithm, input_cfg, output_cfg)  scenario_cfg = Config.configure_scenario(\"my_scenario\", [task_cfg])    if __name__ == \"__main__\":      tp.Core().run()      tp.create_scenario(scenario_cfg)      print(f\"Number of scenarios: {len(tp.get_scenarios())}\") "}
{"text": "import taipy as tp  from taipy import Config      def example_algorithm(entry: str):      # does nothing!      return entry      input_cfg = Config.configure_data_node(\"input\", default_data=\"a_string\")  output_cfg = Config.configure_data_node(\"output\")  task_cfg = Config.configure_task(\"example_algorithm\", example_algorithm, input_cfg, output_cfg)  scenario_cfg = Config.configure_scenario(\"my_scenario\", [task_cfg])    if __name__ == \"__main__\":      tp.Core().run()      tp.create_scenario(scenario_cfg)      print(f\"Number of scenarios: {len(tp.get_scenarios())}\") "}
{"text": "from datetime import datetime    import pandas as pd    from taipy import Config, Frequency, Scope      def write_orders_plan(data: pd.DataFrame):      insert_data = data[[\"date\", \"product_id\", \"number_of_products\"]].to_dict(\"records\")      return [\"DELETE FROM orders\", (\"INSERT INTO orders VALUES (:date, :product_id, :number_of_products)\", insert_data)]      def train(sales_history: pd.DataFrame):      print(\"Running training\")      return \"TRAINED_MODEL\"      def predict(model, current_month):      print(\"Running predicting\")      return \"SALES_PREDICTIONS\"      def plan(sales_predictions, capacity):      print(\"Running planning\")      return \"PRODUCTION_ORDERS\"      def compare(previous_month_prediction, current_month_prediction):      print(\"Comparing previous month and current month sale predictions\")      return \"COMPARISON_RESULT\"      # Configure all six data nodes  sales_history_cfg = Config.configure_csv_data_node(      id=\"sales_history\", scope=Scope.GLOBAL, default_path=\"path/sales.csv\"  )  trained_model_cfg = Config.configure_data_node(id=\"trained_model\", scope=Scope.CYCLE)  current_month_cfg = Config.configure_data_node(id=\"current_month\", scope=Scope.CYCLE, default_data=datetime(2020, 1, 1))  sales_predictions_cfg = Config.configure_data_node(id=\"sales_predictions\", scope=Scope.CYCLE)  capacity_cfg = Config.configure_data_node(id=\"capacity\")  orders_cfg = Config.configure_sql_data_node(      id=\"orders\",      db_username=\"admin\",      db_password=\"ENV[PWD]\",      db_name=\"production_planning\",      db_engine=\"mssql\",      read_query=\"SELECT orders.ID, orders.date, products.price, orders.number_of_products FROM orders INNER JOIN products ON orders.product_id=products.ID\",      write_query_builder=write_orders_plan,      db_driver=\"ODBC Driver 17 for SQL Server\",  )    # Configure the three tasks  training_cfg = Config.configure_task(\"training\", train, sales_history_cfg, [trained_model_cfg])  predicting_cfg = Config.configure_task(      id=\"predicting\", function=predict, input=[trained_model_cfg, current_month_cfg], output=sales_predictions_cfg  )  planning_cfg = Config.configure_task(      id=\"planning\", function=plan, input=[sales_predictions_cfg, capacity_cfg], output=[orders_cfg]  )    # Configure the scenario  monthly_scenario_cfg = Config.configure_scenario(      id=\"scenario_configuration\",      task_configs=[training_cfg, predicting_cfg, planning_cfg],      frequency=Frequency.MONTHLY,      comparators={sales_predictions_cfg.id: compare},      sequences={\"sales\": [training_cfg, predicting_cfg], \"production\": [planning_cfg]},  ) "}
{"text": "import taipy as tp    if __name__ == \"__main__\":      gui = tp.Gui(page=\"# Getting started with *Taipy*\")      rest = tp.Rest()        tp.run(gui, rest, title=\"Taipy application\") "}
{"text": "from taipy import Config  import taipy as tp  import pandas as pd  import datetime as dt      data = pd.read_csv(\"https://raw.githubusercontent.com/Avaiga/taipy-getting-started-core/develop/src/daily-min-temperatures.csv\")      # Normal function used by Taipy  def predict(historical_temperature: pd.DataFrame, date_to_forecast: str) -> float:      print(f\"Running baseline...\")      historical_temperature['Date'] = pd.to_datetime(historical_temperature['Date'])      historical_same_day = historical_temperature.loc[          (historical_temperature['Date'].dt.day == date_to_forecast.day) &          (historical_temperature['Date'].dt.month == date_to_forecast.month)      ]      return historical_same_day['Temp'].mean()    Config.load('config.toml')    if __name__ == '__main__':      scenario_cfg = Config.scenarios['my_scenario']        # Run of the Core      tp.Core().run()        # Creation of the scenario and execution      scenario = tp.create_scenario(scenario_cfg)      scenario.historical_temperature.write(data)      scenario.date_to_forecast.write(dt.datetime.now())      tp.submit(scenario)        print(\"Value at the end of task\", scenario.predictions.read())        def save(state):          state.scenario.historical_temperature.write(data)          state.scenario.date_to_forecast.write(state.date)          tp.gui.notify(state, \"s\", \"Saved! Ready to submit\")        date = None      scenario_md = \"\"\"  <|{scenario}|scenario_selector|>  <|{date}|date|on_change=save|active={scenario}|>  <|{scenario}|scenario|>  <|{scenario}|scenario_dag|>    <|Refresh|button|on_action={lambda s: s.assign(\"scenario\", scenario)}|>  <|{scenario.predictions.read() if scenario else ''}|>  \"\"\"        tp.Gui(scenario_md).run() "}
{"text": "from taipy import Config  import taipy as tp  import pandas as pd  import datetime as dt      data = pd.read_csv(\"https://raw.githubusercontent.com/Avaiga/taipy-getting-started-core/develop/src/daily-min-temperatures.csv\")      # Normal function used by Taipy  def predict(historical_temperature: pd.DataFrame, date_to_forecast: str) -> float:      print(f\"Running baseline...\")      historical_temperature['Date'] = pd.to_datetime(historical_temperature['Date'])      historical_same_day = historical_temperature.loc[          (historical_temperature['Date'].dt.day == date_to_forecast.day) &          (historical_temperature['Date'].dt.month == date_to_forecast.month)      ]      return historical_same_day['Temp'].mean()    # Configuration of Data Nodes  historical_temperature_cfg = Config.configure_data_node(\"historical_temperature\")  date_to_forecast_cfg = Config.configure_data_node(\"date_to_forecast\")  predictions_cfg = Config.configure_data_node(\"predictions\")    # Configuration of tasks  predictions_cfg = Config.configure_task(\"predict\",                                          predict,                                          [historical_temperature_cfg, date_to_forecast_cfg],                                          predictions_cfg)    # Configuration of scenario  scenario_cfg = Config.configure_scenario(id=\"my_scenario\",                                                       task_configs=[predictions_cfg])    Config.export('config.toml')    if __name__ == '__main__':      # Run of the Core      tp.Core().run()        # Creation of the scenario and execution      scenario = tp.create_scenario(scenario_cfg)      scenario.historical_temperature.write(data)      scenario.date_to_forecast.write(dt.datetime.now())      tp.submit(scenario)        print(\"Value at the end of task\", scenario.predictions.read())        def save(state):          state.scenario.historical_temperature.write(data)          state.scenario.date_to_forecast.write(state.date)          tp.gui.notify(state, \"s\", \"Saved! Ready to submit\")        date = None      scenario_md = \"\"\"  <|{scenario}|scenario_selector|>    Put a Date  <|{date}|date|on_change=save|active={scenario}|>    Run the scenario  <|{scenario}|scenario|>  <|{scenario}|scenario_dag|>    View all the information on your prediction here  <|{scenario.predictions if scenario else None}|data_node|>  \"\"\"        tp.Gui(scenario_md).run()      "}
{"text": "from taipy.config import Config, Frequency, Scope  import taipy as tp  import datetime as dt  import pandas as pd      def filter_by_month(df, month):      df['Date'] = pd.to_datetime(df['Date'])       df = df[df['Date'].dt.month == month]      return df      Config.load('config.toml')  scenario_cfg = Config.scenarios[\"my_scenario\"]    if __name__ == '__main__':      tp.Core().run()        scenario_1 = tp.create_scenario(scenario_cfg,                                      creation_date=dt.datetime(2022,10,7),                                      name=\"Scenario 2022/10/7\")      scenario_2 = tp.create_scenario(scenario_cfg,                                      creation_date=dt.datetime(2022,10,5),                                      name=\"Scenario 2022/10/5\")        scenario_1.month.write(10)        print(\"Month Data Node of Scenario 1:\", scenario_1.month.read())      print(\"Month Data Node of Scenario 2:\", scenario_2.month.read())        scenario_1.submit()            before_set_1 = scenario_1.is_primary      before_set_2 = scenario_2.is_primary        tp.set_primary(scenario_2)        print('Scenario 1: Primary?', before_set_1, scenario_1.is_primary)      print('Scenario 2: Primary?', before_set_2, scenario_2.is_primary)        scenario = None      data_node = None        tp.Gui(\"\"\"<|{scenario}|scenario_selector|>                <|{scenario}|scenario|>                <|{scenario}|scenario_dag|>                <|{data_node}|data_node_selector|>\"\"\").run()      "}
{"text": "from taipy.config import Config, Frequency, Scope  import taipy as tp  import datetime as dt  import pandas as pd      def filter_by_month(df, month):      df['Date'] = pd.to_datetime(df['Date'])       df = df[df['Date'].dt.month == month]      return df      historical_data_cfg = Config.configure_csv_data_node(id=\"historical_data\",                                                       default_path=\"time_series.csv\",                                                       scope=Scope.GLOBAL)  month_cfg =  Config.configure_data_node(id=\"month\",                                          scope=Scope.CYCLE)  month_values_cfg =  Config.configure_data_node(id=\"month_data\",                                                 scope=Scope.CYCLE)      task_filter_cfg = Config.configure_task(id=\"filter_by_month\",                                          function=filter_by_month,                                          input=[historical_data_cfg, month_cfg],                                          output=month_values_cfg)      scenario_cfg = Config.configure_scenario(id=\"my_scenario\",                                           task_configs=[task_filter_cfg],                                           frequency=Frequency.MONTHLY)    Config.export('step_04/onfig.toml')    if __name__ == '__main__':      tp.Core().run()        scenario_1 = tp.create_scenario(scenario_cfg,                                      creation_date=dt.datetime(2022,10,7),                                      name=\"Scenario 2022/10/7\")      scenario_2 = tp.create_scenario(scenario_cfg,                                      creation_date=dt.datetime(2022,10,5),                                      name=\"Scenario 2022/10/5\")        scenario_1.month.write(10)        print(\"Month Data Node of Scenario 1:\", scenario_1.month.read())      print(\"Month Data Node of Scenario 2:\", scenario_2.month.read())        scenario_1.submit()            before_set_1 = scenario_1.is_primary      before_set_2 = scenario_2.is_primary        tp.set_primary(scenario_2)        print('Scenario 1: Primary?', before_set_1, scenario_1.is_primary)      print('Scenario 2: Primary?', before_set_2, scenario_2.is_primary)        scenario = None      data_node = None        tp.Gui(\"\"\"<|{scenario}|scenario_selector|>                <|{scenario}|scenario|>                <|{scenario}|scenario_dag|>                <|{data_node}|data_node_selector|>\"\"\").run()      "}
{"text": "from taipy.core.config import Config  import taipy as tp  import datetime as dt  import pandas as pd  import time    # Normal function used by Taipy  def double(nb):      return nb * 2    def add(nb):      print(\"Wait 10 seconds in add function\")      time.sleep(10)      return nb + 10      Config.load('config.toml')  Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)      if __name__==\"__main__\":      scenario_cfg = Config.scenarios['my_scenario']      tp.Core().run()      scenario_1 = tp.create_scenario(scenario_cfg)      scenario_2 = tp.create_scenario(scenario_cfg)      scenario_1.submit()      scenario_2.submit()        scenario_1 = tp.create_scenario(scenario_cfg)      scenario_1.submit(wait=True)      scenario_1.submit(wait=True, timeout=5) "}
{"text": "from taipy.core.config import Config  import taipy as tp  import datetime as dt  import pandas as pd  import time    # Normal function used by Taipy  def double(nb):      return nb * 2    def add(nb):      print(\"Wait 10 seconds in add function\")      time.sleep(10)      return nb + 10    Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)    # Configuration of Data Nodes  input_cfg = Config.configure_data_node(\"input\", default_data=21)  intermediate_cfg = Config.configure_data_node(\"intermediate\", default_data=21)  output_cfg = Config.configure_data_node(\"output\")    # Configuration of tasks  first_task_cfg = Config.configure_task(\"double\",                                         double,                                         input_cfg,                                         intermediate_cfg)    second_task_cfg = Config.configure_task(\"add\",                                          add,                                          intermediate_cfg,                                          output_cfg)    # Configuration of the scenario  scenario_cfg = Config.configure_scenario(id=\"my_scenario\",                                           task_configs=[first_task_cfg,                                                         second_task_cfg])    Config.export(\"config.toml\")    if __name__==\"__main__\":      tp.Core().run()      scenario_1 = tp.create_scenario(scenario_cfg)      scenario_2 = tp.create_scenario(scenario_cfg)      scenario_1.submit()      scenario_2.submit()        scenario_1 = tp.create_scenario(scenario_cfg)      scenario_1.submit(wait=True)      scenario_1.submit(wait=True, timeout=5) "}
{"text": "from taipy.core.config import Config  import taipy as tp      # Normal function used by Taipy  def double(nb):      return nb * 2    def add(nb):      return nb + 10      # Configuration of Data Nodes  input_cfg = Config.configure_data_node(\"input\", default_data=21)  intermediate_cfg = Config.configure_data_node(\"intermediate\")  output_cfg = Config.configure_data_node(\"output\")    # Configuration of tasks  first_task_cfg = Config.configure_task(\"double\",                                         double,                                         input_cfg,                                         intermediate_cfg)    second_task_cfg = Config.configure_task(\"add\",                                          add,                                          intermediate_cfg,                                          output_cfg)        def compare_function(*data_node_results):      # example of function      compare_result = {}      current_res_i = 0      for current_res in data_node_results:          compare_result[current_res_i] = {}          next_res_i = 0          for next_res in data_node_results:              print(f\"comparing result {current_res_i} with result {next_res_i}\")              compare_result[current_res_i][next_res_i] = next_res - current_res              next_res_i += 1          current_res_i += 1      return compare_result      scenario_cfg = Config.configure_scenario(id=\"multiply_scenario\",                                                      name=\"my_scenario\",                                                      task_configs=[first_task_cfg, second_task_cfg],                                                      comparators={output_cfg.id: compare_function})    Config.export(\"config_08.toml\")    if __name__==\"__main__\":      tp.Core().run()        scenario_1 = tp.create_scenario(scenario_cfg)      scenario_2 = tp.create_scenario(scenario_cfg)        scenario_1.input.write(10)      scenario_2.input.write(8)        scenario_1.submit()      scenario_2.submit()            print(tp.compare_scenarios(scenario_1, scenario_2))      "}
{"text": "from taipy.gui import Gui, notify    text = \"Original text\"    # Definition of the page  page = \"\"\"  # Getting started with Taipy GUI    My text: <|{text}|>    <|{text}|input|>    <|Run local|button|on_action=on_button_action|>  \"\"\"    def on_button_action(state):      notify(state, 'info', f'The text is: {state.text}')      state.text = \"Button Pressed\"    def on_change(state, var_name, var_value):      if var_name == \"text\" and var_value == \"Reset\":          state.text = \"\"          return      Gui(page).run(debug=True) "}
{"text": "from transformers import AutoTokenizer  from transformers import AutoModelForSequenceClassification  from scipy.special import softmax    import numpy as np  import pandas as pd   from taipy.gui import Gui, notify    text = \"Original text\"    page = \"\"\"  # Getting started with Taipy GUI    <|layout|columns=1 1|  <|  My text: <|{text}|>    Enter a word:  <|{text}|input|>  <|Analyze|button|on_action=local_callback|>  |>      <|Table|expandable|  <|{dataframe}|table|width=100%|number_format=%.2f|>  |>  |>    <|layout|columns=1 1 1|  ## Positive <|{np.mean(dataframe['Score Pos'])}|text|format=%.2f|raw|>    ## Neutral <|{np.mean(dataframe['Score Neu'])}|text|format=%.2f|raw|>    ## Negative <|{np.mean(dataframe['Score Neg'])}|text|format=%.2f|raw|>  |>    <|{dataframe}|chart|type=bar|x=Text|y[1]=Score Pos|y[2]=Score Neu|y[3]=Score Neg|y[4]=Overall|color[1]=green|color[2]=grey|color[3]=red|type[4]=line|>  \"\"\"    MODEL = f\"cardiffnlp/twitter-roberta-base-sentiment\"  tokenizer = AutoTokenizer.from_pretrained(MODEL)  model = AutoModelForSequenceClassification.from_pretrained(MODEL)    dataframe = pd.DataFrame({\"Text\":[''],                            \"Score Pos\":[0.33],                            \"Score Neu\":[0.33],                            \"Score Neg\":[0.33],                            \"Overall\":[0]})    dataframe2 = dataframe.copy()    def analyze_text(text):      # Run for Roberta Model      encoded_text = tokenizer(text, return_tensors='pt')      output = model(**encoded_text)      scores = output[0][0].detach().numpy()      scores = softmax(scores)            return {\"Text\":text[:50],              \"Score Pos\":scores[2],              \"Score Neu\":scores[1],              \"Score Neg\":scores[0],              \"Overall\":scores[2]-scores[0]}      def local_callback(state):      notify(state, 'Info', f'The text is: {state.text}', True)      temp = state.dataframe.copy()      scores = analyze_text(state.text)      temp.loc[len(temp)] = scores      state.dataframe = temp      state.text = \"\"      path = \"\"  treatment = 0    page_file = \"\"\"  <|{path}|file_selector|extensions=.txt|label=Upload .txt file|on_action=analyze_file|> <|{f'Downloading {treatment}%...'}|>    <br/>    <|Table|expandable|  <|{dataframe2}|table|width=100%|number_format=%.2f|>  |>    <br/>    <|{dataframe2}|chart|type=bar|x=Text|y[1]=Score Pos|y[2]=Score Neu|y[3]=Score Neg|y[4]=Overall|color[1]=green|color[2]=grey|color[3]=red|type[4]=line|height=600px|>    \"\"\"    def analyze_file(state):      state.dataframe2 = dataframe2      state.treatment = 0      with open(state.path,\"r\", encoding='utf-8') as f:          data = f.read()                    # split lines and eliminates duplicates          file_list = list(dict.fromkeys(data.replace('\\n', ' ').split(\".\")[:-1]))                  for i in range(len(file_list)):          text = file_list[i]          state.treatment = int((i+1)*100/len(file_list))          temp = state.dataframe2.copy()          scores = analyze_text(text)          temp.loc[len(temp)] = scores          state.dataframe2 = temp                state.path = None          pages = {\"/\":\"<|toggle|theme|>\\n<center>\\n<|navbar|>\\n</center>\",           \"line\":page,           \"text\":page_file}      Gui(pages=pages).run(debug=True)"}
{"text": "from transformers import AutoTokenizer  from transformers import AutoModelForSequenceClassification  from scipy.special import softmax    import numpy as np  import pandas as pd   from taipy.gui import Gui, notify    text = \"Original text\"    page = \"\"\"  # Getting started with Taipy GUI    <|layout|columns=1 1|  <|  My text: <|{text}|>    Enter a word:  <|{text}|input|>  <|Analyze|button|on_action=local_callback|>  |>      <|Table|expandable|  <|{dataframe}|table|width=100%|number_format=%.2f|>  |>  |>    <|layout|columns=1 1 1|  ## Positive <|{float(np.mean(dataframe['Score Pos']))}|text|format=%.2f|raw|>%    ## Neutral <|{float(np.mean(dataframe['Score Neu']))}|text|format=%.2f|raw|>%    ## Negative <|{float(np.mean(dataframe['Score Neg']))}|text|format=%.2f|raw|>%  |>    <br/>    <|{dataframe}|chart|type=bar|x=Text|y[1]=Score Pos|y[2]=Score Neu|y[3]=Score Neg|y[4]=Overall|color[1]=green|color[2]=grey|color[3]=red|type[4]=line|>  \"\"\"    MODEL = f\"cardiffnlp/twitter-roberta-base-sentiment\"  tokenizer = AutoTokenizer.from_pretrained(MODEL)  model = AutoModelForSequenceClassification.from_pretrained(MODEL)    dataframe = pd.DataFrame({\"Text\":[''],                            \"Score Pos\":[0.33],                            \"Score Neu\":[0.33],                            \"Score Neg\":[0.33],                            \"Overall\":[0]})      def analyze_text(text):      # Run for Roberta Model      encoded_text = tokenizer(text, return_tensors='pt')      output = model(**encoded_text)      scores = output[0][0].detach().numpy()      scores = softmax(scores)            return {\"Text\":text,              \"Score Pos\":scores[2],              \"Score Neu\":scores[1],              \"Score Neg\":scores[0],              \"Overall\":scores[2]-scores[0]}      def local_callback(state):      notify(state, 'Info', f'The text is: {state.text}', True)      temp = state.dataframe.copy()      scores = analyze_text(state.text)      temp.loc[len(temp)] = scores      state.dataframe = temp      state.text = \"\"    Gui(page).run(debug=True)"}
{"text": "from taipy.gui import Gui    text = \"Original text\"    page = \"\"\"  # Getting started with Taipy GUI    My text: <|{text}|>    <|{text}|input|>  \"\"\"    Gui(page).run(debug=True)"}
{"text": "  from transformers import AutoTokenizer  from transformers import AutoModelForSequenceClassification  from scipy.special import softmax    import numpy as np  import pandas as pd   from taipy.gui import Gui, notify    text = \"Original text\"    MODEL = f\"cardiffnlp/twitter-roberta-base-sentiment\"  tokenizer = AutoTokenizer.from_pretrained(MODEL)  model = AutoModelForSequenceClassification.from_pretrained(MODEL)    dataframe = pd.DataFrame({\"Text\":[''],                            \"Score Pos\":[0.33],                            \"Score Neu\":[0.33],                            \"Score Neg\":[0.33],                            \"Overall\":[0]})    # Torch is, for now, only available for the Python version between 3.8 and 3.10.   # If you cannot install these packages, just return a dictionary of random numbers for the `analyze_text(text).`  def analyze_text(text):      # Run for Roberta Model      encoded_text = tokenizer(text, return_tensors='pt')      output = model(**encoded_text)      scores = output[0][0].detach().numpy()      scores = softmax(scores)            return {\"Text\":text,              \"Score Pos\":scores[2],              \"Score Neu\":scores[1],              \"Score Neg\":scores[0],              \"Overall\":scores[2]-scores[0]}      def local_callback(state):      notify(state, 'Info', f'The text is: {state.text}', True)      temp = state.dataframe.copy()      scores = analyze_text(state.text)      temp.loc[len(temp)] = scores      state.dataframe = temp      state.text = \"\"        page = \"\"\"  <|toggle|theme|>    # Getting started with Taipy GUI    My text: <|{text}|>    Enter a word:    <|{text}|input|>    <|Analyze|button|on_action=local_callback|>    ## Positive  <|{float(np.mean(dataframe['Score Pos']))}|text|format=%.2f|>%    ## Neutral  <|{float(np.mean(dataframe['Score Neu']))}|text|format=%.2f|>%    ## Negative  <|{float(np.mean(dataframe['Score Neg']))}|text|format=%.2f|>%    <|{dataframe}|table|number_format=%.2f|>    <|{dataframe}|chart|type=bar|x=Text|y[1]=Score Pos|y[2]=Score Neu|y[3]=Score Neg|y[4]=Overall|color[1]=green|color[2]=grey|color[3]=red|type[4]=line|>  \"\"\"    Gui(page).run(debug=True)"}
{"text": "from taipy import Gui    Gui(page=\"# Getting started with *Taipy*\").run(debug=True) "}
{"text": "import pandas as pd   from taipy.gui import Gui, notify      text = \"Original text\"    page = \"\"\"  <|toggle|theme|>    # Getting started with Taipy GUI    My text: <|{text}|>    <|{text}|input|>    <|Analyze|button|on_action=local_callback|>    <|{dataframe}|table|number_format=%.2f|>    <|{dataframe}|chart|type=bar|x=Text|y[1]=Score Pos|y[2]=Score Neu|y[3]=Score Neg|y[4]=Overall|color[1]=green|color[2]=grey|color[3]=red|type[4]=line|>  \"\"\"    dataframe = pd.DataFrame({\"Text\":['Test', 'Other', 'Love'],                            \"Score Pos\":[1, 1, 4],                            \"Score Neu\":[2, 3, 1],                            \"Score Neg\":[1, 2, 0],                            \"Overall\":[0, -1, 4]})      def local_callback(state):      notify(state, 'info', f'The text is: {state.text}')            temp = state.dataframe.copy()      temp.loc[len(temp)] = {\"Text\":state.text,                              \"Score Pos\":0,                              \"Score Neu\":0,                              \"Score Neg\":0,                              \"Overall\":0}      state.dataframe = temp      state.text = \"\"    Gui(page).run(debug=True)"}
{"text": "from taipy.config import Config  from taipy.core import Status  import taipy as tp  import time      # Normal function used by Taipy  def double(nb):      return nb * 2    def add(nb):      return nb + 10      # Configuration of Data Nodes  input_cfg = Config.configure_data_node(\"input\", default_data=21)  intermediate_cfg = Config.configure_data_node(\"intermediate\")  output_cfg = Config.configure_data_node(\"output\")      # Configuration of tasks  first_task_cfg = Config.configure_task(\"double\",                                         double,                                         input_cfg,                                         intermediate_cfg)    second_task_cfg = Config.configure_task(\"add\",                                          add,                                          intermediate_cfg,                                          output_cfg)      def callback_scenario_state(scenario, job):      \"\"\"All the scenarios are subscribed to the callback_scenario_state function. It means whenever a job is done, it is called.      Depending on the job and the status, it will update the message stored in a json that is then displayed on the GUI.        Args:          scenario (Scenario): the scenario of the job changed          job (_type_): the job that has its status changed      \"\"\"      print(f'{job.id} to {job.status}')        if job.status == Status.COMPLETED:          for data_node in job.task.output.values():              print(\"Data node value:\", data_node.read())    # Configuration of scenario  scenario_cfg = Config.configure_scenario(id=\"my_scenario\",                                           task_configs=[first_task_cfg, second_task_cfg],                                           name=\"my_scenario\")        if __name__==\"__main__\":      tp.Core().run()      scenario_1 = tp.create_scenario(scenario_cfg)      scenario_1.subscribe(callback_scenario_state)        scenario_1.submit(wait=True)      from taipy.gui import Gui, notify    def on_submission_status_change(state=None, submittable=None, details=None):      submission_status = details.get('submission_status')        if submission_status == 'COMPLETED':          print(f\"{submittable.name} has completed.\")          notify(state, 'success', 'Completed!')          # Add additional actions here, like updating the GUI or logging the completion.            elif submission_status == 'FAILED':          print(f\"{submittable.name} has failed.\")          notify(state, 'error', 'Completed!')          # Handle failure, like sending notifications or logging the error.            # Add more conditions for other statuses as needed.        if __name__==\"__main__\":      scenario_md = \"\"\"  <|{scenario_1}|scenario|on_submission_change=on_submission_status_change|>  \"\"\"      Gui(scenario_md).run() "}
{"text": "\"\"\"  A multi-page Taipy application, which includes 3 pages:  - A rootpage which is shared by other pages.  - Two pages named page_1 and page_2.    Please refer to ../../manuals/gui/pages for more details.  \"\"\"    from pages import data_viz, scenario_page, performance  from pages.root import *    from configuration.config import *    from taipy.gui import Gui  import taipy as tp    def on_change(state, var_name: str, var_value):      state['scenario'].on_change(state, var_name, var_value)      pages = {      \"/\": root_page,      \"data_viz\": data_viz,      \"scenario\": scenario_page,      \"performance\": performance  }        if __name__ == \"__main__\":      tp.Core().run()      gui = Gui(pages=pages)      gui.run(title=\"Taipy Application\") "}
{"text": "import datetime as dt  import pandas as pd    from taipy import Config, Scope, Frequency    from algorithms.algorithms import *    path_to_csv = \"data/dataset.csv\"    # Datanodes (3.1)  ## Input Data Nodes  initial_dataset_cfg = Config.configure_data_node(id=\"initial_dataset\",                                                   storage_type=\"csv\",                                                   path=path_to_csv,                                                   scope=Scope.GLOBAL)    # We assume the current day is the 26th of July 2021.  # This day can be changed to simulate multiple executions of scenarios on different days  day_cfg = Config.configure_data_node(id=\"day\", default_data=dt.datetime(2021, 7, 26))    n_predictions_cfg = Config.configure_data_node(id=\"n_predictions\", default_data=40)    max_capacity_cfg = Config.configure_data_node(id=\"max_capacity\", default_data=200)    ## Remaining Data Nodes  cleaned_dataset_cfg = Config.configure_data_node(id=\"cleaned_dataset\",                                                   scope=Scope.GLOBAL)    predictions_baseline_cfg = Config.configure_data_node(id=\"predictions_baseline\")  predictions_ml_cfg = Config.configure_data_node(id=\"predictions_ml\")    full_predictions_cfg = Config.configure_data_node(id=\"full_predictions\")    metrics_baseline_cfg = Config.configure_data_node(id=\"metrics_baseline\")  metrics_ml_cfg = Config.configure_data_node(id=\"metrics_ml\")    # Functions (3.2)    # Tasks (3.3)  clean_data_task_cfg = Config.configure_task(id=\"task_clean_data\",                                              function=clean_data,                                              input=initial_dataset_cfg,                                              output=cleaned_dataset_cfg,                                              skippable=True)      predict_baseline_task_cfg = Config.configure_task(id=\"predict_baseline\",                                                    function=predict_baseline,                                                    input=[cleaned_dataset_cfg, n_predictions_cfg, day_cfg,                                                           max_capacity_cfg],                                                    output=predictions_baseline_cfg)    predict_ml_task_cfg = Config.configure_task(id=\"task_predict_ml\",                                              function=predict_ml,                                              input=[cleaned_dataset_cfg,                                                     n_predictions_cfg, day_cfg,                                                     max_capacity_cfg],                                              output=predictions_ml_cfg)      metrics_baseline_task_cfg = Config.configure_task(id=\"task_metrics_baseline\",                                              function=compute_metrics,                                              input=[cleaned_dataset_cfg,                                                     predictions_baseline_cfg],                                              output=metrics_baseline_cfg)    metrics_ml_task_cfg = Config.configure_task(id=\"task_metrics_ml\",                                              function=compute_metrics,                                              input=[cleaned_dataset_cfg,                                                     predictions_ml_cfg],                                              output=metrics_ml_cfg)      full_predictions_task_cfg = Config.configure_task(id=\"task_full_predictions\",                                              function=create_predictions_dataset,                                              input=[predictions_baseline_cfg,                                                     predictions_ml_cfg,                                                    day_cfg,                                                    n_predictions_cfg,                                                    cleaned_dataset_cfg],                                              output=full_predictions_cfg)      # Configure our scenario which is our business problem.  scenario_cfg = Config.configure_scenario(id=\"scenario\",                                           task_configs=[clean_data_task_cfg,                                                          predict_baseline_task_cfg,                                                          predict_ml_task_cfg,                                                          metrics_baseline_task_cfg,                                                          metrics_ml_task_cfg,                                                          full_predictions_task_cfg],                                           frequency=Frequency.WEEKLY) "}
{"text": "# To make things clear, we've opted for an AutoRegressive model instead of a pure ML model like:  # Random Forest, Linear Regression, LSTM, etc     from statsmodels.tsa.ar_model import AutoReg  import pandas as pd  from sklearn.metrics import mean_squared_error, mean_absolute_error  import numpy as np  import datetime as dt    def clean_data(initial_dataset: pd.DataFrame):      print(\"     Cleaning data\")      # Convert the date column to datetime      initial_dataset['Date'] = pd.to_datetime(initial_dataset['Date'])      cleaned_dataset = initial_dataset.copy()      return cleaned_dataset      def predict_baseline(cleaned_dataset: pd.DataFrame, n_predictions: int, day: dt.datetime, max_capacity: int):      print(\"     Predicting baseline\")      # Select the train data      train_dataset = cleaned_dataset[cleaned_dataset['Date'] < day]        predictions = train_dataset['Value'][-n_predictions:].reset_index(drop=True)      predictions = predictions.apply(lambda x: min(x, max_capacity))      return predictions      # This is the function that will be used by the task  def predict_ml(cleaned_dataset: pd.DataFrame, n_predictions: int, day: dt.datetime, max_capacity: int):      print(\"     Predicting with ML\")      # Select the train data      train_dataset = cleaned_dataset[cleaned_dataset[\"Date\"] < day]        # Fit the AutoRegressive model      model = AutoReg(train_dataset[\"Value\"], lags=7).fit()        # Get the n_predictions forecasts      predictions = model.forecast(n_predictions).reset_index(drop=True)      predictions = predictions.apply(lambda x: min(x, max_capacity))      return predictions      def compute_metrics(historical_data, predicted_data):      historical_to_compare = historical_data[-len(predicted_data):]['Value']      rmse = mean_squared_error(historical_to_compare, predicted_data)      mae = mean_absolute_error(historical_to_compare, predicted_data)      return rmse, mae      def create_predictions_dataset(predictions_baseline, predictions_ml, day, n_predictions, cleaned_data):      print(\"Creating predictions dataset...\")            # Create the historical dataset that will be displayed      new_length = len(cleaned_data[cleaned_data[\"Date\"] < day]) + n_predictions      historical_data = cleaned_data[:new_length].reset_index(drop=True)        create_series = lambda data, name: pd.Series([np.NaN] * (len(historical_data)), name=name).fillna({i: val for i, val in enumerate(data, len(historical_data)-n_predictions)})        predictions_dataset = pd.concat([          historical_data[\"Date\"],          historical_data[\"Value\"].rename(\"Historical values\"),          create_series(predictions_ml, \"Predicted values ML\"),          create_series(predictions_baseline, \"Predicted values Baseline\")      ], axis=1)        return predictions_dataset "}
{"text": "from .data_viz import data_viz  from .scenario import scenario_page  from .performance import performance  from .root import root_page "}
{"text": "\"\"\"  The rootpage of the application.  Page content is imported from the root.md file.    Please refer to ../../manuals/gui/pages for more details.  \"\"\"    from taipy.gui import Markdown    root_page = Markdown(\"pages/root.md\") "}
{"text": "from .scenario import scenario_page "}
{"text": "\"\"\"  The second page of the application.  Page content is imported from the page_2.md file.    Please refer to ../../manuals/gui/pages for more details.  \"\"\"    from taipy.gui import Markdown, notify  import datetime as dt  import pandas as pd      scenario = None  data_node = None  day = dt.datetime(2021, 7, 26)  n_predictions = 40  max_capacity = 200  predictions_dataset = {\"Date\":[dt.datetime(2021, 7, 26)],                          \"Predicted values ML\":[0],                         \"Predicted values Baseline\":[0],                         \"Historical values\":[0]}    def submission_change(state, submittable, details: dict):      if details['submission_status'] == 'COMPLETED':          notify(state, \"success\", 'Scenario completed!')          state['scenario'].on_change(state, 'scenario', state.scenario)      else:          notify(state, \"error\", 'Something went wrong!')      def save(state):      print(\"Saving scenario...\")      # Get the currently selected scenario        # Conversion to the right format      state_day = dt.datetime(state.day.year, state.day.month, state.day.day)        # Change the default parameters by writing in the Data Nodes      state.scenario.day.write(state_day)      state.scenario.n_predictions.write(int(state.n_predictions))      state.scenario.max_capacity.write(int(state.max_capacity))      notify(state, \"success\", \"Saved!\")          def on_change(state, var_name, var_value):      if var_name == \"scenario\" and var_value:          state.day = state.scenario.day.read()          state.n_predictions = state.scenario.n_predictions.read()          state.max_capacity = state.scenario.max_capacity.read()                    if state.scenario.full_predictions.is_ready_for_reading:              state.predictions_dataset = state.scenario.full_predictions.read()[-200:]          else:              state.predictions_dataset = predictions_dataset      scenario_page = Markdown(\"pages/scenario/scenario.md\") "}
{"text": "from .data_viz import data_viz "}
{"text": "\"\"\"  The first page of the application.  Page content is imported from the page_1.md file.    Please refer to ../../manuals/gui/pages for more details.  \"\"\"    from taipy.gui import Markdown  import pandas as pd    def get_data(path_to_csv: str):      # pandas.read_csv() returns a pd.DataFrame      dataset = pd.read_csv(path_to_csv)      dataset[\"Date\"] = pd.to_datetime(dataset[\"Date\"])      return dataset    # Read the dataframe  path_to_csv = \"data/dataset.csv\"  dataset = get_data(path_to_csv)    # Initial value  n_week = 10    # Select the week based on the slider value  dataset_week = dataset[dataset[\"Date\"].dt.isocalendar().week == n_week]    def on_slider(state):      state.dataset_week = dataset[dataset[\"Date\"].dt.isocalendar().week == state.n_week]      data_viz = Markdown(\"pages/data_viz/data_viz.md\") "}
{"text": "from .performance import performance "}
{"text": "from taipy.gui import Markdown    import pandas as pd  import taipy as tp    # Initial dataset for comparison  comparison_scenario = pd.DataFrame(columns=[\"Scenario Name\",                                              \"RMSE baseline\",                                              \"MAE baseline\",                                              \"RMSE ML\",                                              \"MAE ML\"])      # Selector for metrics  metric_selector = [\"RMSE\", \"MAE\"]  selected_metric = metric_selector[0]      def compare(state):      print(\"Comparing...\")        # Initialize lists for comparison      scenario_data = []        # Go through all the primary scenarios      all_scenarios = sorted(tp.get_primary_scenarios(), key=lambda x: x.creation_date.timestamp())        for scenario in all_scenarios:          rmse_baseline, mae_baseline = scenario.metrics_baseline.read()          rmse_ml, mae_ml = scenario.metrics_ml.read()              # Store scenario data in a dictionary          scenario_data.append({              \"Scenario Name\": scenario.name,              \"RMSE baseline\": rmse_baseline,              \"MAE baseline\": mae_baseline,              \"RMSE ML\": rmse_ml,              \"MAE ML\": mae_ml          })        # Create a DataFrame from the scenario_data list      state.comparison_scenario = pd.DataFrame(scenario_data)    performance = Markdown(\"pages/performance/performance.md\") "}
{"text": "import taipy as tp  from taipy import Config, Core, Gui      ################################################################  #            Configure application                             #  ################################################################  def build_message(name):      return f\"Hello {name}!\"      # A first data node configuration to model an input name.  input_name_data_node_cfg = Config.configure_data_node(id=\"input_name\")  # A second data node configuration to model the message to display.  message_data_node_cfg = Config.configure_data_node(id=\"message\")  # A task configuration to model the build_message function.  build_msg_task_cfg = Config.configure_task(\"build_msg\", build_message, input_name_data_node_cfg, message_data_node_cfg)  # The scenario configuration represents the whole execution graph.  scenario_cfg = Config.configure_scenario(\"scenario\", task_configs=[build_msg_task_cfg])    ################################################################  #            Design graphical interface                        #  ################################################################    input_name = \"Taipy\"  message = None      def submit_scenario(state):      state.scenario.input_name.write(state.input_name)      state.scenario.submit()      state.message = scenario.message.read()    page = \"\"\"  Name: <|{input_name}|input|>    <|submit|button|on_action=submit_scenario|>    Message: <|{message}|text|>  \"\"\"    if __name__ == \"__main__\":      ################################################################      #            Instantiate and run Core service                  #      ################################################################      Core().run()        ################################################################      #            Manage scenarios and data nodes                   #      ################################################################      scenario = tp.create_scenario(scenario_cfg)        ################################################################      #            Instantiate and run Gui service                   #      ################################################################        Gui(page).run()   "}
{"text": "import taipy as tp  from taipy import Config, Core      ################################################################  #            Configure application                             #  ################################################################  def build_message(name):      return f\"Hello {name}!\"      # A first data node configuration to model an input name.  input_name_data_node_cfg = Config.configure_data_node(id=\"input_name\")  # A second data node configuration to model the message to display.  message_data_node_cfg = Config.configure_data_node(id=\"message\")  # A task configuration to model the build_message function.  build_msg_task_cfg = Config.configure_task(\"build_msg\", build_message, input_name_data_node_cfg, message_data_node_cfg)  # The scenario configuration represents the whole execution graph.  scenario_cfg = Config.configure_scenario(\"scenario\", task_configs=[build_msg_task_cfg])    if __name__ == \"__main__\":      ################################################################      #            Instantiate and run Core service                  #      ################################################################      Core().run()        ################################################################      #            Manage scenarios and data nodes                   #      ################################################################      hello_scenario = tp.create_scenario(scenario_cfg)        hello_scenario.input_name.write(\"Taipy\")      hello_scenario.submit()      print(hello_scenario.message.read()) "}
{"text": "import taipy as tp    from taipy import Gui  from taipy import Config  from taipy import Core    # Configure application      def build_message(name: str)-> str:      return f\"Received message :  {name}\"    # A first data node configuration to model an input name.  input_name_data_node_cfg = Config.configure_data_node(id=\"input_name\")  # A second data node configuration to model the message to display  message_data_node_cfg = Config.configure_data_node(id=\"message\")  # Configure task between input and output data nodes  build_msg_task_cfg = Config.configure_task(\"build_msg\", build_message, input_name_data_node_cfg,message_data_node_cfg)  # Scenario Configuration to represent execution graph  scenario_cfg = Config.configure_scenario(\"scenario\", task_configs=[build_msg_task_cfg])    # Function to handle state from GUI  input_name = \"Taipy\"  message = None    def submit_scenario(state):      state.scenario.input_name.write(state.input_name)      state.scenario.submit()      state.message = scenario.message.read()    # Markdown representation of the user interface  page = \"\"\"  Name: <|{input_name}|input|>  <|submit|button|on_action=submit_scenario|>    Message: <|{message}|text|>  \"\"\"    if __name__ == \"__main__\":      # Instantiate and run Core service       Core().run()        # Instantiate the new scenario name hello_scenario from the scenario configuration built before      hello_scenario = tp.create_scenario(scenario_cfg)        # Run GUI      Gui(page).run()"}
{"text": "import taipy as tp    from taipy import Config  from taipy import Core    def build_message(name: str)-> str:      return f\"Received message :  {name}\"    # A first data node configuration to model an input name.  input_name_data_node_cfg = Config.configure_data_node(id=\"input_name\")  # A second data node configuration to model the message to display  message_data_node_cfg = Config.configure_data_node(id=\"message\")  # Configure task between input and output data nodes  build_msg_task_cfg = Config.configure_task(\"build_msg\", build_message, input_name_data_node_cfg,message_data_node_cfg)  # Scenario Configuration to represent execution graph  scenario_cfg = Config.configure_scenario(\"scenario\", task_configs=[build_msg_task_cfg])    if __name__ == \"__main__\":      # Instantiate and run Core service       Core().run()        # Instantiate the new scenario name hello_scenario from the scenario configuration built before      hello_scenario = tp.create_scenario(scenario_cfg)        # sets the input data node input_name of hello_scenario with the string value       hello_scenario.input_name.write(\"In God We Trust !\")        # submits the hello_scenario for execution, which triggers the creation and execution of a job      hello_scenario.submit()        # reads and prints the output data node message written by the execution of the scenario hello_scenario      print(hello_scenario.message.read())"}
{"text": "print(\"----------------------------------------------\")  print(\"---------------------TEST---------------------\")  print(\"----------------------------------------------\") "}
{"text": "import os  import shutil    import pytest      @pytest.fixture(scope=\"function\")  def tmp_sqlite(tmpdir_factory):      fn = tmpdir_factory.mktemp(\"db\")      return os.path.join(fn.strpath, \"test.db\")      @pytest.fixture(autouse=True)  def cleanup_data():      from time import sleep        from sqlalchemy.orm import close_all_sessions        close_all_sessions()        sleep(0.1)      if os.path.exists(\".data\"):          shutil.rmtree(\".data\", ignore_errors=True)      if os.path.exists(\"test.db\"):          os.remove(\"test.db\")        init_managers()      init_config()      init_orchestrator()      init_managers()      init_config()      def init_config():      from taipy import Config      from taipy.config import IssueCollector      from taipy.config._config import _Config      from taipy.config._serializer._toml_serializer import _TomlSerializer      from taipy.config.checker._checker import _Checker      from taipy.core.config import (          CoreSection,          DataNodeConfig,          JobConfig,          ScenarioConfig,          TaskConfig,          _DataNodeConfigChecker,          _inject_section,          _JobConfigChecker,          _ScenarioConfigChecker,          _TaskConfigChecker,      )        Config.unblock_update()      Config._default_config = _Config()._default_config()      Config._python_config = _Config()      Config._file_config = None      Config._env_file_config = None      Config._applied_config = _Config._default_config()      Config._collector = IssueCollector()      Config._serializer = _TomlSerializer()      _Checker._checkers = []        _inject_section(          JobConfig, \"job_config\", JobConfig(\"development\"), [(\"configure_job_executions\", JobConfig._configure)], True      )      _inject_section(          DataNodeConfig,          \"data_nodes\",          DataNodeConfig.default_config(),          [              (\"configure_data_node\", DataNodeConfig._configure),              (\"configure_default_data_node\", DataNodeConfig._set_default_configuration),              (\"configure_csv_data_node\", DataNodeConfig._configure_csv),              (\"configure_json_data_node\", DataNodeConfig._configure_json),              (\"configure_sql_table_data_node\", DataNodeConfig._configure_sql_table),              (\"configure_sql_data_node\", DataNodeConfig._configure_sql),              (\"configure_mongo_collection_data_node\", DataNodeConfig._configure_mongo_collection),              (\"configure_in_memory_data_node\", DataNodeConfig._configure_in_memory),              (\"configure_pickle_data_node\", DataNodeConfig._configure_pickle),              (\"configure_excel_data_node\", DataNodeConfig._configure_excel),              (\"configure_generic_data_node\", DataNodeConfig._configure_generic),          ],      )      _inject_section(          TaskConfig,          \"tasks\",          TaskConfig.default_config(),          [(\"configure_task\", TaskConfig._configure), (\"configure_default_task\", TaskConfig._set_default_configuration)],      )      _inject_section(          ScenarioConfig,          \"scenarios\",          ScenarioConfig.default_config(),          [              (\"configure_scenario\", ScenarioConfig._configure),              (\"configure_default_scenario\", ScenarioConfig._set_default_configuration),          ],      )      _inject_section(          CoreSection,          \"core\",          CoreSection.default_config(),          [(\"configure_core\", CoreSection._configure)],          add_to_unconflicted_sections=True,      )      _Checker.add_checker(_JobConfigChecker)      _Checker.add_checker(_DataNodeConfigChecker)      _Checker.add_checker(_TaskConfigChecker)      _Checker.add_checker(_ScenarioConfigChecker)      def init_managers():      from taipy.core._version._version_manager_factory import _VersionManagerFactory      from taipy.core.cycle._cycle_manager_factory import _CycleManagerFactory      from taipy.core.data._data_manager_factory import _DataManagerFactory      from taipy.core.job._job_manager_factory import _JobManagerFactory      from taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory      from taipy.core.sequence._sequence_manager_factory import _SequenceManagerFactory      from taipy.core.task._task_manager_factory import _TaskManagerFactory        _CycleManagerFactory._build_manager()._delete_all()      _ScenarioManagerFactory._build_manager()._delete_all()      _SequenceManagerFactory._build_manager()._delete_all()      _JobManagerFactory._build_manager()._delete_all()      _TaskManagerFactory._build_manager()._delete_all()      _DataManagerFactory._build_manager()._delete_all()      _VersionManagerFactory._build_manager()._delete_all()      def init_orchestrator():      from queue import Queue        from taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory        if _OrchestratorFactory._orchestrator is None:          _OrchestratorFactory._build_orchestrator()      _OrchestratorFactory._build_dispatcher(force_restart=True)      _OrchestratorFactory._orchestrator.jobs_to_run = Queue()      _OrchestratorFactory._orchestrator.blocked_jobs = [] "}
{"text": "import os  import pickle    import taipy.core as tp  from taipy.config import Config      def test_pickle_files():      from tests.shared_test_cases.pickle_files import (          PICKLE_DICT_INPUT_PATH,          PICKLE_DICT_OUTPUT_PATH,          PICKLE_LIST_INPUT_PATH,          PICKLE_LIST_OUTPUT_PATH,          ROW_COUNT,          gen_list_of_dict_input_pickle,          gen_list_of_objects_input_pickle,          scenario_cfg_1,          scenario_cfg_2,      )        tp.clean_all_entities_by_version(None)        # generate 2 pickles files      gen_list_of_dict_input_pickle(PICKLE_DICT_INPUT_PATH, ROW_COUNT)      gen_list_of_objects_input_pickle(PICKLE_LIST_INPUT_PATH, ROW_COUNT)        with open(PICKLE_DICT_INPUT_PATH, \"rb\") as f:          dict_data = pickle.load(f)      with open(PICKLE_LIST_INPUT_PATH, \"rb\") as f:          list_data = pickle.load(f)        # \ud83d\udcdd List of dicts        scenario_1 = tp.create_scenario(scenario_cfg_1)      input_data_node_1 = scenario_1.input_pickle_dataset_1      output_data_node_1 = scenario_1.output_pickle_dataset_1        read_data_1 = input_data_node_1.read()      assert len(read_data_1) == ROW_COUNT      assert read_data_1 == dict_data        assert output_data_node_1.read() is None      output_data_node_1.write(read_data_1)      assert dict_data == output_data_node_1.read()        output_data_node_1.write(None)      assert output_data_node_1.read() is None        scenario_1.submit()      assert dict_data == output_data_node_1.read()        os.remove(PICKLE_DICT_INPUT_PATH)      os.remove(PICKLE_DICT_OUTPUT_PATH)        # \ud83d\udcdd List of objects      scenario_2 = tp.create_scenario(scenario_cfg_2)      input_data_node_2 = scenario_2.input_pickle_dataset_2      output_data_node_2 = scenario_2.output_pickle_dataset_2        read_data_2 = input_data_node_2.read()      assert len(read_data_2) == ROW_COUNT      assert read_data_2 == list_data        assert output_data_node_2.read() is None      output_data_node_2.write(read_data_2)      assert list_data == output_data_node_2.read()        output_data_node_2.write(None)      assert output_data_node_2.read() is None        scenario_2.submit()      assert list_data == output_data_node_2.read()        os.remove(PICKLE_LIST_INPUT_PATH)      os.remove(PICKLE_LIST_OUTPUT_PATH) "}
{"text": "import os  import shutil  from io import StringIO  from unittest.mock import patch    import pytest  from taipy._cli._scaffold_cli import _ScaffoldCLI  from taipy._entrypoint import _entrypoint    from tests.utils import clean_subparser      @pytest.fixture(autouse=True, scope=\"function\")  def clean_templates():      clean_subparser()        yield        if os.path.exists(\"foo_app\"):          shutil.rmtree(\"foo_app\", ignore_errors=True)      if os.path.exists(\"bar_app\"):          shutil.rmtree(\"bar_app\", ignore_errors=True)      def test_default_template():      assert os.path.exists(_ScaffoldCLI._TEMPLATE_MAP[\"default\"])        inputs = \"\\n\".join([\"foo_app\", \"main.py\", \"bar\", \"\", \"\", \"\"])      with pytest.raises(SystemExit) as error:          with patch(\"sys.stdin\", StringIO(f\"{inputs}\\n\")):              with patch(\"sys.argv\", [\"prog\", \"create\"]):                  _entrypoint()      assert \"foo_app\" in os.listdir(os.getcwd())      assert error.value.code == 0        clean_subparser()        inputs = \"\\n\".join([\"bar_app\", \"main.py\", \"bar\", \"\", \"\", \"\"])      with pytest.raises(SystemExit) as error:          with patch(\"sys.stdin\", StringIO(f\"{inputs}\\n\")):              with patch(\"sys.argv\", [\"prog\", \"create\", \"--template\", \"default\"]):                  _entrypoint()      assert \"bar_app\" in os.listdir(os.getcwd())      assert error.value.code == 0      def test_scenario_management_template():      assert os.path.exists(_ScaffoldCLI._TEMPLATE_MAP[\"scenario-management\"])        inputs = \"\\n\".join([\"foo_app\", \"main.py\", \"bar\", \"\"])      with pytest.raises(SystemExit) as error:          with patch(\"sys.stdin\", StringIO(f\"{inputs}\\n\")):              with patch(\"sys.argv\", [\"prog\", \"create\", \"--template\", \"scenario-management\"]):                  _entrypoint()      assert \"foo_app\" in os.listdir(os.getcwd())      assert error.value.code == 0      def test_non_existing_template(capsys):      with pytest.raises(SystemExit) as error:          with patch(\"sys.argv\", [\"prog\", \"create\", \"--template\", \"non-existing-template\"]):              _entrypoint()        assert error.value.code == 2        _, err_msg = capsys.readouterr()      assert \"argument --template: invalid choice: 'non-existing-template' (choose from\" in err_msg "}
{"text": "import os  from unittest.mock import patch    import pandas as pd  import taipy.core.taipy as tp  from taipy.config import Config  from taipy.core import Core  from taipy.core.config.job_config import JobConfig  from taipy.core.job.status import Status    from .complex_application_configs import (      average,      build_churn_classification_config,      build_complex_config,      build_complex_required_file_paths,      build_skipped_jobs_config,  )      def assert_true_after_time(assertion, msg=None, time=120):      from datetime import datetime      from time import sleep        start = datetime.now()      while (datetime.now() - start).seconds < time:          sleep(1)  # Limit CPU usage          try:              if assertion():                  return          except BaseException as e:              print(\"Raise : \", e)              continue      if msg:          print(msg)      assert assertion()      def test_skipped_jobs():      scenario_config = build_skipped_jobs_config()        with patch(\"sys.argv\", [\"prog\"]):          Core().run()        scenario = tp.create_scenario(scenario_config)      scenario.input.write(2)      scenario.submit()      assert len(tp.get_jobs()) == 2      for job in tp.get_jobs():          assert job.status == Status.COMPLETED        scenario.submit()      assert len(tp.get_jobs()) == 4      skipped = []      for job in tp.get_jobs():          if job.status != Status.COMPLETED:              assert job.status == Status.SKIPPED              skipped.append(job)      assert len(skipped) == 2      def test_complex_development():      # d1 --- t1      # |      # | --- t2 --- d5 --- |                   t10 --- d12      #        |            |                   |      #        |            |                   |      #        d2           | --- t5 --- d7 --- t7 --- d9 --- t8 --- d10 --- t9 --- d11      #                     |                   |             |      # d3 --- |            |                   |             |      # |      |            |     t6 --- d8 -------------------      # |      t3 --- d6 ---|      # |      |      # |      |      # t4     d4        _, _, csv_path_sum, excel_path_sum, excel_path_out, csv_path_out = build_complex_required_file_paths()      scenario_config = build_complex_config()        with patch(\"sys.argv\", [\"prog\"]):          Core().run(force_restart=True)        scenario = tp.create_scenario(scenario_config)        tp.submit(scenario)        csv_sum_res = pd.read_csv(csv_path_sum)      excel_sum_res = pd.read_excel(excel_path_sum)      csv_out = pd.read_csv(csv_path_out)      excel_out = pd.read_excel(excel_path_out)      assert csv_sum_res.to_numpy().flatten().tolist() == [i * 20 for i in range(1, 11)]      assert excel_sum_res.to_numpy().flatten().tolist() == [i * 2 for i in range(1, 11)]      assert average(csv_sum_res[\"number\"] - excel_sum_res[\"number\"]) == csv_out.to_numpy()[0]      assert average((csv_sum_res[\"number\"] - excel_sum_res[\"number\"]) * 10) == excel_out.to_numpy()[0]        for path in [csv_path_sum, excel_path_sum, csv_path_out, excel_path_out]:          os.remove(path)      def test_complex_standlone():      # d1 --- t1      # |      # | --- t2 --- d5 --- |                   t10 --- d12      #        |            |                   |      #        |            |                   |      #        d2           | --- t5 --- d7 --- t7 --- d9 --- t8 --- d10 --- t9 --- d11      #                     |                   |             |      # d3 --- |            |                   |             |      # |      |            |     t6 --- d8 -------------------      # |      t3 --- d6 ---|      # |      |      # |      |      # t4     d4        _, _, csv_path_sum, excel_path_sum, excel_path_out, csv_path_out = build_complex_required_file_paths()      scenario_config = build_complex_config()      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        with patch(\"sys.argv\", [\"prog\"]):          Core().run(force_restart=True)        scenario = tp.create_scenario(scenario_config)        jobs = tp.submit(scenario)        assert_true_after_time(lambda: os.path.exists(csv_path_out) and os.path.exists(excel_path_out))      assert_true_after_time(lambda: all([job._status == Status.COMPLETED for job in jobs]))        csv_sum_res = pd.read_csv(csv_path_sum)      excel_sum_res = pd.read_excel(excel_path_sum)      csv_out = pd.read_csv(csv_path_out)      excel_out = pd.read_excel(excel_path_out)        assert csv_sum_res.to_numpy().flatten().tolist() == [i * 20 for i in range(1, 11)]      assert excel_sum_res.to_numpy().flatten().tolist() == [i * 2 for i in range(1, 11)]      assert average(csv_sum_res[\"number\"] - excel_sum_res[\"number\"]) == csv_out.to_numpy()[0]      assert average((csv_sum_res[\"number\"] - excel_sum_res[\"number\"]) * 10) == excel_out.to_numpy()[0]        for path in [csv_path_sum, excel_path_sum, csv_path_out, excel_path_out]:          os.remove(path)      def test_churn_classification_development():      scenario_cfg = build_churn_classification_config()        with patch(\"sys.argv\", [\"prog\"]):          Core().run(force_restart=True)        scenario = tp.create_scenario(scenario_cfg)      jobs = tp.submit(scenario)      for job in jobs:          if not job.is_completed():              print(job._task.config_id)        assert all([job.is_completed() for job in jobs])      def test_churn_classification_standalone():      scenario_cfg = build_churn_classification_config()      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        with patch(\"sys.argv\", [\"prog\"]):          Core().run(force_restart=True)        scenario = tp.create_scenario(scenario_cfg)      jobs = tp.submit(scenario)        assert_true_after_time(lambda: os.path.exists(scenario.results._path))      assert_true_after_time(lambda: all([job._status == Status.COMPLETED for job in jobs]), time=15) "}
{"text": "from typing import Optional    from flask_testing import TestCase  from taipy.rest import Rest  from tests.shared_test_cases.arima import build_arima_config      class BaseTestCase(TestCase):      def create_app(self):          rest = Rest()          rest._app.config[\"TESTING\"] = True          return rest._app      class RestTest(BaseTestCase):      def _create(self, entity: str, config_id: str):          return self.client.post(f\"/api/v1/{entity}?config_id={config_id}\")        def _get(self, entity: str, id: Optional[str] = None):          url = f\"/api/v1/{entity}\"          if id:              url = f\"{url}/{id}\"          return self.client.get(url)        def test_create_scenario_should_create_every_entity(self):          build_arima_config()            response = self._create(\"scenarios\", \"Arima_scenario\")          assert response.status_code == 201          assert response.json[\"message\"] == \"Scenario was created.\"            all_scenarios = self._get(\"scenarios\")          all_data_nodes = self._get(\"datanodes\")          all_tasks = self._get(\"tasks\")            assert len(all_scenarios.json) == 1          assert len(all_data_nodes.json) == 4          assert len(all_tasks.json) == 2        def test_submit_scenario(self):          build_arima_config()            response = self._create(\"scenarios\", \"Arima_scenario\")          assert response.status_code == 201          scenario_id = response.json[\"scenario\"][\"id\"]            response = self.client.post(f\"/api/v1/scenarios/submit/{scenario_id}\")          assert response.status_code == 200          assert response.json == {\"message\": f\"Scenario {scenario_id} was submitted.\"}            all_jobs = self._get(\"jobs\")          for jb in all_jobs.json:              assert jb[\"status\"] == \"Status.COMPLETED\" "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import taipy as tp  from tests.shared_test_cases.arima.config import build_arima_config      def test_submit_scenario_submit_success():      arima_scenario_config = build_arima_config()      scenario = tp.create_scenario(arima_scenario_config)      tp.submit(scenario)        assert scenario.forecast_values.read() is not None      assert len(tp.get_tasks()) == 2      assert len(tp.get_jobs()) == 2      assert len(tp.get_data_nodes()) == 4 "}
{"text": "from taipy._cli._base_cli import _CLI      def clean_subparser():      if getattr(_CLI._parser, \"_subparsers\", None):          # Loop over all subparsers to find the one that has nested-subparsers and positional arguments          for choice in _CLI._parser._subparsers._group_actions[0].choices.values():                # Remove nested _subparsers              choice._subparsers = None                # Remove positional arguments              # The \"==SUPPRESS==\" is a hack to identify nested-subparsers as positional arguments              to_remove = [\"application_main_file\", \"==SUPPRESS==\"]                actions = choice._actions.copy()              for action in actions:                  opts = action.option_strings                  if (opts and opts[0] in to_remove) or action.dest in to_remove:                      choice._remove_action(action)                for argument_group in choice._action_groups:                  for group_action in argument_group._group_actions:                      opts = group_action.option_strings                      if (opts and opts[0] in to_remove) or group_action.dest in to_remove:                          argument_group._group_actions.remove(group_action)      def assert_true_after_time(assertion, msg=None, time=120):      from datetime import datetime      from time import sleep        start = datetime.now()      while (datetime.now() - start).seconds < time:          print(f\"waiting {(datetime.now() - start).seconds} seconds...\", end=\"\\r\")          try:              if assertion():                  print(f\"waiting {(datetime.now() - start).seconds} seconds...\")                  return          except BaseException as e:              print(\"Raise : \", e)              sleep(1)  # Limit CPU usage              continue      print(f\"waiting {(datetime.now() - start).seconds} seconds...\")      if msg:          print(msg)      assert assertion() "}
{"text": "import os    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  import taipy.core as tp  from taipy.config import Config      def test_excel():      from tests.shared_test_cases.single_excel_sheet import (          EXCEL_SINGLE_SHEET_INPUT_PATH,          EXCEL_SINGLE_SHEET_OUTPUT_PATH,          ROW_COUNT,          Row,          scenario_cfg,          scenario_cfg_2,          scenario_cfg_3,          scenario_cfg_4,      )        pandas_data = pd.read_excel(EXCEL_SINGLE_SHEET_INPUT_PATH)      numpy_data = pandas_data.to_numpy()      modin_data = modin_pd.read_excel(EXCEL_SINGLE_SHEET_INPUT_PATH)      custom_data = [          Row(int(v.id), int(v.age), float(v.rating)) for i, v in pd.read_excel(EXCEL_SINGLE_SHEET_INPUT_PATH).iterrows()      ]        tp.clean_all_entities_by_version(None)        # \ud83d\udcca Without exposed type (pandas is the default exposed type)        scenario_1 = tp.create_scenario(scenario_cfg)      input_data_node_1 = scenario_1.input_excel_single_sheet_dataset_1      output_data_node_1 = scenario_1.output_excel_single_sheet_dataset_1        read_data_1 = input_data_node_1.read()      assert len(read_data_1) == ROW_COUNT      assert pandas_data.equals(read_data_1)        assert output_data_node_1.read() is None      output_data_node_1.write(read_data_1)      assert pandas_data.equals(output_data_node_1.read())        output_data_node_1.write(None)      assert output_data_node_1.read().empty        scenario_1.submit()      assert pandas_data.equals(output_data_node_1.read())        os.remove(EXCEL_SINGLE_SHEET_OUTPUT_PATH)        # \ud83d\udcca With custom class as exposed type        def compare_custom_date(read_data, custom_data):          return [              row_1.id == row_2.id and row_1.age == row_2.age and row_1.rating == row_2.rating              for row_1, row_2 in zip(read_data, custom_data)          ]        scenario_2 = tp.create_scenario(scenario_cfg_2)      input_data_node_2 = scenario_2.input_excel_single_sheet_dataset_2      output_data_node_2 = scenario_2.output_excel_single_sheet_dataset_2        read_data_2 = input_data_node_2.read()      assert len(read_data_2) == ROW_COUNT      assert all(compare_custom_date(read_data_2, custom_data))        output_data_node_2.write(read_data_2)      assert len(read_data_2) == ROW_COUNT      assert all(compare_custom_date(output_data_node_2.read(), custom_data))        output_data_node_2.write(None)      assert isinstance(output_data_node_2.read(), list)      assert len(output_data_node_2.read()) == 0        scenario_2.submit()      assert all(compare_custom_date(output_data_node_2.read(), custom_data))        os.remove(EXCEL_SINGLE_SHEET_OUTPUT_PATH)        # \ud83d\udcca With numpy as exposed type      scenario_3 = tp.create_scenario(scenario_cfg_3)      input_data_node_3 = scenario_3.input_excel_single_sheet_dataset_3      output_data_node_3 = scenario_3.output_excel_single_sheet_dataset_3        read_data_3 = input_data_node_3.read()      assert len(read_data_3) == ROW_COUNT      assert np.array_equal(read_data_3, numpy_data)        assert output_data_node_3.read() is None      output_data_node_3.write(read_data_3)      assert np.array_equal(output_data_node_3.read(), numpy_data)        output_data_node_3.write(None)      assert isinstance(output_data_node_3.read(), np.ndarray)      assert output_data_node_3.read().size == 0        scenario_3.submit()      assert np.array_equal(output_data_node_3.read(), numpy_data)        os.remove(EXCEL_SINGLE_SHEET_OUTPUT_PATH)        # \ud83d\udcca With modin as exposed type      scenario_4 = tp.create_scenario(scenario_cfg_4)      input_data_node_4 = scenario_4.input_excel_single_sheet_dataset_4      output_data_node_4 = scenario_4.output_excel_single_sheet_dataset_4        read_data_4 = input_data_node_4.read()      assert len(read_data_4) == ROW_COUNT      assert all(modin_data._to_pandas() == read_data_4._to_pandas())        assert output_data_node_4.read() is None      output_data_node_4.write(read_data_4)      assert all(modin_data._to_pandas() == output_data_node_4.read()._to_pandas())        output_data_node_4.write(None)      assert output_data_node_4.read().empty        scenario_4.submit()      assert all(modin_data._to_pandas() == output_data_node_4.read()._to_pandas())        os.remove(EXCEL_SINGLE_SHEET_OUTPUT_PATH) "}
{"text": "import json  import os    import taipy.core as tp  from taipy.config import Config      def test_json():      from tests.shared_test_cases.json_files import (          JSON_DICT_INPUT_PATH,          JSON_DICT_OUTPUT_PATH,          JSON_OBJECT_INPUT_PATH,          JSON_OBJECT_OUTPUT_PATH,          ROW_COUNT,          Row,          RowDecoder,          scenario_cfg_1,          scenario_cfg_2,      )        tp.clean_all_entities_by_version(None)        with open(JSON_DICT_INPUT_PATH, \"r\") as f:          json_dict_data = json.load(f)      with open(JSON_OBJECT_INPUT_PATH, \"r\") as f:          json_object_data = json.load(f, cls=RowDecoder)        # \ud83d\udcdd Without encoder / decoder        scenario_1 = tp.create_scenario(scenario_cfg_1)      input_data_node_1 = scenario_1.input_json_dataset_1      output_data_node_1 = scenario_1.output_json_dataset_1        read_data_1 = input_data_node_1.read()      assert len(read_data_1) == ROW_COUNT      assert json_dict_data == read_data_1        assert output_data_node_1.read() is None      output_data_node_1.write(read_data_1)      assert json_dict_data == output_data_node_1.read()        output_data_node_1.write(None)      assert output_data_node_1.read() is None        scenario_1.submit()      assert json_dict_data == output_data_node_1.read()        os.remove(JSON_DICT_OUTPUT_PATH)        # \ud83d\udcdd With encoder / decoder        def compare_custom_date(read_data, object_data):          return [              isinstance(row_1, Row) and row_1.id == row_2.id and row_1.age == row_2.age and row_1.rating == row_2.rating              for row_1, row_2 in zip(read_data, object_data)          ]        scenario_2 = tp.create_scenario(scenario_cfg_2)      input_data_node_2 = scenario_2.input_json_dataset_2      output_data_node_2 = scenario_2.output_json_dataset_2        read_data_2 = input_data_node_2.read()      assert len(read_data_2) == ROW_COUNT      assert all(compare_custom_date(read_data_2, json_object_data))        assert output_data_node_2.read() is None      output_data_node_2.write(read_data_2)      assert all(compare_custom_date(output_data_node_2.read(), json_object_data))        output_data_node_2.write(None)      assert output_data_node_2.read() is None        scenario_2.submit()      assert all(compare_custom_date(output_data_node_2.read(), json_object_data))        os.remove(JSON_OBJECT_OUTPUT_PATH) "}
{"text": "from unittest.mock import patch    import pytest  from taipy._entrypoint import _entrypoint    from tests.utils import clean_subparser      @pytest.fixture(autouse=True, scope=\"function\")  def clean_templates():      clean_subparser()      yield      def test_run_simple_taipy_app_without_taipy_args(capfd):      with pytest.raises(SystemExit) as error:          with patch(\"sys.argv\", [\"prog\", \"run\", \"tests/simple_application/no_external_args_app.py\"]):              _entrypoint()      std_out, _ = capfd.readouterr()      assert error.value.code == 0      assert \"Development mode: Clean all entities of version\" in std_out        assert \"Config.core.version_number: \" in std_out      assert \"Config.core.mode: development\" in std_out      assert \"Config.core.force: False\" in std_out      assert \"Config.gui_config.host: 127.0.0.1\" in std_out      assert \"Config.gui_config.port: 5000\" in std_out      assert \"Config.gui_config.debug: False\" in std_out      assert \"Config.gui_config.use_reloader: False\" in std_out      assert \"Config.gui_config.ngrok_token: \" in std_out      assert \"Config.gui_config.webapp_path: None\" in std_out      def test_run_simple_taipy_app_with_taipy_args(capfd):      with pytest.raises(SystemExit):          with patch(              \"sys.argv\",              [                  \"prog\",                  \"run\",                  \"tests/simple_application/no_external_args_app.py\",                  \"--experiment\",                  \"1.0\",                  \"--force\",                  \"--host\",                  \"example.com\",                  \"--port\",                  \"5001\",                  \"--debug\",                  \"--use-reloader\",                  \"--ngrok-token\",                  \"1234567890\",                  \"--webapp-path\",                  \"path/webapp\",              ],          ):              _entrypoint()        std_out, _ = capfd.readouterr()      assert \"Config.core.version_number: 1.0\" in std_out      assert \"Config.core.mode: experiment\" in std_out      assert \"Config.core.force: True\" in std_out      assert \"Config.gui_config.host: example.com\" in std_out      assert \"Config.gui_config.port: 5001\" in std_out      assert \"Config.gui_config.debug: True\" in std_out      assert \"Config.gui_config.use_reloader: True\" in std_out      assert \"Config.gui_config.ngrok_token: 1234567890\" in std_out      assert \"Config.gui_config.webapp_path: path/webapp\" in std_out      def test_run_simple_taipy_app_with_taipy_and_external_args(capfd):      with pytest.raises(SystemExit):          with patch(              \"sys.argv\",              [                  \"prog\",                  \"run\",                  \"tests/simple_application/external_args_app.py\",                  \"--experiment\",                  \"1.0\",                  \"--force\",                  \"--host\",                  \"example.com\",                  \"--port\",                  \"5001\",                  \"external-args\",  # This is the keyword that separates external args from taipy args                  \"--mode\",                  \"inference\",                  \"--force\",                  \"yes\",                  \"--host\",                  \"user_host.com\",                  \"--port\",                  \"8081\",                  \"--non-conflict-arg\",                  \"non-conflict-arg-value\",              ],          ):              _entrypoint()        std_out, _ = capfd.readouterr()      assert \"Config.core.mode: experiment\" in std_out      assert \"User provided mode: inference\" in std_out      assert \"Config.core.force: True\" in std_out      assert \"User provided force: yes\" in std_out      assert \"Config.gui_config.host: example.com\" in std_out      assert \"User provided host: user_host.com\" in std_out      assert \"Config.gui_config.port: 5001\" in std_out      assert \"User provided port: 8081\" in std_out      assert \"User provided non-conflict-arg: non-conflict-arg-value\" in std_out "}
{"text": "import os    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  import taipy.core as tp  from taipy.config import Config      def test_csv():      from tests.shared_test_cases.csv_files.config import (          CSV_INPUT_PATH,          CSV_OUTPUT_PATH,          ROW_COUNT,          Row,          scenario_cfg,          scenario_cfg_2,          scenario_cfg_3,          scenario_cfg_4,      )        tp.clean_all_entities_by_version(None)        pandas_data = pd.read_csv(CSV_INPUT_PATH)      numpy_data = pandas_data.to_numpy()      modin_data = modin_pd.read_csv(CSV_INPUT_PATH)      custom_data = [Row(int(v.id), int(v.age), float(v.rating)) for i, v in pd.read_csv(CSV_INPUT_PATH).iterrows()]        # \ud83d\udcca Without exposed type (pandas is the default exposed type)        scenario_1 = tp.create_scenario(scenario_cfg)      input_data_node_1 = scenario_1.input_csv_dataset_1      output_data_node_1 = scenario_1.output_csv_dataset_1        read_data_1 = input_data_node_1.read()      assert len(read_data_1) == ROW_COUNT      assert pandas_data.equals(read_data_1)        assert output_data_node_1.read() is None      output_data_node_1.write(read_data_1)      assert pandas_data.equals(output_data_node_1.read())        output_data_node_1.write(None)      assert output_data_node_1.read().empty        scenario_1.submit()      assert pandas_data.equals(output_data_node_1.read())        os.remove(CSV_OUTPUT_PATH)        # \ud83d\udcca With custom class as exposed type        def compare_custom_date(read_data, custom_data):          return [              row_1.id == row_2.id and row_1.age == row_2.age and row_1.rating == row_2.rating              for row_1, row_2 in zip(read_data, custom_data)          ]        scenario_2 = tp.create_scenario(scenario_cfg_2)      input_data_node_2 = scenario_2.input_csv_dataset_2      output_data_node_2 = scenario_2.output_csv_dataset_2        read_data_2 = input_data_node_2.read()      assert len(read_data_2) == ROW_COUNT      assert all(compare_custom_date(read_data_2, custom_data))        output_data_node_2.write(read_data_2)      assert len(read_data_2) == ROW_COUNT      assert all(compare_custom_date(output_data_node_2.read(), custom_data))        output_data_node_2.write(None)      assert isinstance(output_data_node_2.read(), list)      assert len(output_data_node_2.read()) == 0        scenario_2.submit()      assert all(compare_custom_date(output_data_node_2.read(), custom_data))        os.remove(CSV_OUTPUT_PATH)        # \ud83d\udcca With numpy as exposed type      scenario_3 = tp.create_scenario(scenario_cfg_3)      input_data_node_3 = scenario_3.input_csv_dataset_3      output_data_node_3 = scenario_3.output_csv_dataset_3        read_data_3 = input_data_node_3.read()      assert len(read_data_3) == ROW_COUNT      assert np.array_equal(read_data_3, numpy_data)        assert output_data_node_3.read() is None      output_data_node_3.write(read_data_3)      assert np.array_equal(output_data_node_3.read(), numpy_data)        output_data_node_3.write(None)      assert isinstance(output_data_node_3.read(), np.ndarray)      assert output_data_node_3.read().size == 0        scenario_3.submit()      assert np.array_equal(output_data_node_3.read(), numpy_data)        os.remove(CSV_OUTPUT_PATH)        # \ud83d\udcca With modin as exposed type      scenario_4 = tp.create_scenario(scenario_cfg_4)      input_data_node_4 = scenario_4.input_csv_dataset_4      output_data_node_4 = scenario_4.output_csv_dataset_4        read_data_4 = input_data_node_4.read()      assert len(read_data_4) == ROW_COUNT      assert all(modin_data._to_pandas() == read_data_4._to_pandas())        assert output_data_node_4.read() is None      output_data_node_4.write(read_data_4)      assert all(modin_data._to_pandas() == output_data_node_4.read()._to_pandas())        output_data_node_4.write(None)      assert output_data_node_4.read().empty        scenario_4.submit()      assert all(modin_data._to_pandas() == output_data_node_4.read()._to_pandas())        os.remove(CSV_OUTPUT_PATH) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import random  import time  from datetime import datetime  from typing import Dict, List    import pandas as pd      def failing_job(historical_daily_temperature: pd.DataFrame):      time.sleep(2)      print(\"----- Prepared to raise exception -----\")      raise Exception      def predict(model, dates: List[datetime]) -> Dict[str, List[float]]:      res = [t + random.uniform(0, 3) for t in model.forecast(len(dates))]      return {\"result\": res} "}
{"text": "from datetime import datetime    from taipy import Frequency, Scope  from taipy.config.config import Config    from .algorithms import failing_job, predict    historical_data_set = Config.configure_csv_data_node(      id=\"historical_data_set\", path=\"tests//shared_test_cases/arima/daily-min-temperatures.csv\", scope=Scope.GLOBAL  )    arima_model = Config.configure_data_node(id=\"arima_model\")    dates_to_forecast = Config.configure_data_node(      id=\"dates_to_forecast\", scope=Scope.SCENARIO, default_data=[datetime(1991, 1, 1).isoformat()]  )    forecast_values = Config.configure_excel_data_node(      id=\"forecast_values\", has_header=False, path=\"tests//shared_test_cases/arima/res.xlsx\"  )    arima_fail_algo = Config.configure_task(      id=\"arima_training\", input=historical_data_set, function=failing_job, output=arima_model  )    arima_scoring_algo = Config.configure_task(      id=\"arima_scoring\", input=[arima_model, dates_to_forecast], function=predict, output=forecast_values  )    arima_sequence = Config.configure_sequence(id=\"arima_sequences\", task_configs=[arima_fail_algo, arima_scoring_algo])    arima_scenario_config = Config.configure_scenario(      id=\"Arima_scenario\", sequence_configs=[arima_sequence], frequency=Frequency.DAILY  ) "}
{"text": "from .algorithms import *  from .config import * "}
{"text": "import random  import time  from datetime import datetime  from typing import Dict, List    import pandas as pd  from statsmodels.tsa.arima.model import ARIMA      def train(historical_daily_temperature: pd.DataFrame):      print(\"----- Started training -----\")      time.sleep(2)      for _ in range(2):          print(\"----- Model is in training -----\")      return ARIMA(endog=historical_daily_temperature[\"Temp\"].to_numpy(), order=(1, 1, 0)).fit()      def predict(model, dates: List[datetime]) -> Dict[str, List]:      res = [t + random.uniform(0, 3) for t in model.forecast(len(dates))]      return {\"result\": res} "}
{"text": "from datetime import datetime    from taipy.config import Frequency, Scope  from taipy.config.config import Config    from .algorithms import predict, train    def build_arima_config():        CSV_INPUT_PATH = \"tests/shared_test_cases/arima/daily-min-temperatures.csv\"      XLSX_OUTPUT_PATH = \"tests/shared_test_cases/arima/res.xlsx\"        historical_data_set = Config.configure_csv_data_node(id=\"historical_data_set\", path=CSV_INPUT_PATH, scope=Scope.GLOBAL)        arima_model = Config.configure_data_node(id=\"arima_model\")        dates_to_forecast = Config.configure_data_node(          id=\"dates_to_forecast\", scope=Scope.SCENARIO, default_data=[datetime(1991, 1, 1).isoformat()]      )        forecast_values = Config.configure_excel_data_node(id=\"forecast_values\", has_header=False, path=XLSX_OUTPUT_PATH)        arima_training_algo = Config.configure_task(          id=\"arima_training\", input=historical_data_set, function=train, output=arima_model      )        arima_scoring_algo = Config.configure_task(          id=\"arima_scoring\", input=[arima_model, dates_to_forecast], function=predict, output=forecast_values      )        arima_scenario_config = Config.configure_scenario(          id=\"Arima_scenario\", task_configs=[arima_training_algo, arima_scoring_algo], frequency=Frequency.DAILY      )        return arima_scenario_config "}
{"text": "from .algorithms import *  from .config import * "}
{"text": "import pandas as pd      def algorithm(df: pd.DataFrame) -> pd.DataFrame:      return df "}
{"text": "import dataclasses    from taipy.config.common.frequency import Frequency  from taipy.config.config import Config    from .algorithms import algorithm    CSV_INPUT_PATH = \"tests/shared_test_cases/csv_files/input_1000.csv\"  CSV_OUTPUT_PATH = \"tests/shared_test_cases/csv_files/output_1000.csv\"  ROW_COUNT = 1000      @dataclasses.dataclass  class Row:      id: int      age: int      rating: float        def __post_init__(self):          for field in dataclasses.fields(self):              value = getattr(self, field.name)              if not isinstance(value, field.type):                  setattr(self, field.name, field.type(value))      Config.unblock_update()  # Config for Pandas  input_dataset_cfg = Config.configure_csv_data_node(id=\"input_csv_dataset_1\", path=CSV_INPUT_PATH, has_header=True)  output_dataset_cfg = Config.configure_csv_data_node(id=\"output_csv_dataset_1\", path=CSV_OUTPUT_PATH, has_header=True)  task_cfg = Config.configure_task(id=\"t1\", input=input_dataset_cfg, function=algorithm, output=output_dataset_cfg)  scenario_cfg = Config.configure_scenario(id=\"s1\", task_configs=[task_cfg], frequency=Frequency.DAILY)    # Config for Custom class  input_dataset_cfg_2 = Config.configure_csv_data_node(      id=\"input_csv_dataset_2\", path=CSV_INPUT_PATH, has_header=True, exposed_type=Row  )  output_dataset_cfg_2 = Config.configure_csv_data_node(      id=\"output_csv_dataset_2\", path=CSV_OUTPUT_PATH, has_header=True, exposed_type=Row  )  task_cfg_2 = Config.configure_task(id=\"t2\", input=input_dataset_cfg_2, function=algorithm, output=output_dataset_cfg_2)  scenario_cfg_2 = Config.configure_scenario(id=\"s2\", task_configs=[task_cfg_2], frequency=Frequency.DAILY)    # Config for Numpy  input_dataset_cfg_3 = Config.configure_csv_data_node(      id=\"input_csv_dataset_3\", path=CSV_INPUT_PATH, has_header=True, exposed_type=\"numpy\"  )  output_dataset_cfg_3 = Config.configure_csv_data_node(      id=\"output_csv_dataset_3\", path=CSV_OUTPUT_PATH, has_header=True, exposed_type=\"numpy\"  )  task_cfg_3 = Config.configure_task(id=\"t3\", input=input_dataset_cfg_3, function=algorithm, output=output_dataset_cfg_3)  scenario_cfg_3 = Config.configure_scenario(id=\"s3\", task_configs=[task_cfg_3], frequency=Frequency.DAILY)    # Config for Modin  input_dataset_cfg_4 = Config.configure_csv_data_node(      id=\"input_csv_dataset_4\", path=CSV_INPUT_PATH, has_header=True, exposed_type=\"modin\"  )  output_dataset_cfg_4 = Config.configure_csv_data_node(      id=\"output_csv_dataset_4\", path=CSV_OUTPUT_PATH, has_header=True, exposed_type=\"modin\"  )  task_cfg_4 = Config.configure_task(id=\"t4\", input=input_dataset_cfg_4, function=algorithm, output=output_dataset_cfg_4)  scenario_cfg_4 = Config.configure_scenario(id=\"s4\", task_configs=[task_cfg_4], frequency=Frequency.DAILY) "}
{"text": "from .algorithms import *  from .config import * "}
{"text": "import pandas as pd      def algorithm(df: pd.DataFrame) -> pd.DataFrame:      return df "}
{"text": "import dataclasses    from taipy.config.common.frequency import Frequency  from taipy.config.config import Config    from .algorithms import algorithm    EXCEL_INPUT_PATH = \"tests/shared_test_cases/multi_excel_sheets/input_1000_multi_sheets.xlsx\"  EXCEL_OUTPUT_PATH = \"tests/shared_test_cases/multi_excel_sheets/output_1000.xlsx\"  ROW_COUNT = 1000  SHEET_NAMES = [\"Sheet 0\", \"Sheet 1\", \"Sheet 2\", \"Sheet 3\", \"Sheet 4\", \"Sheet 5\"]      @dataclasses.dataclass  class Row:      id: int      age: int      rating: float        def __post_init__(self):          for field in dataclasses.fields(self):              value = getattr(self, field.name)              if not isinstance(value, field.type):                  setattr(self, field.name, field.type(value))      Config.unblock_update()    input_dataset_cfg_1 = Config.configure_excel_data_node(      id=\"input_excel_multi_sheet_dataset_1\", path=EXCEL_INPUT_PATH, has_header=True, sheet_name=SHEET_NAMES  )  output_dataset_cfg_1 = Config.configure_excel_data_node(      id=\"output_excel_multi_sheet_dataset_1\", path=EXCEL_OUTPUT_PATH, has_header=True, sheet_name=SHEET_NAMES  )  task_cfg = Config.configure_task(id=\"t1\", input=input_dataset_cfg_1, function=algorithm, output=output_dataset_cfg_1)  scenario_cfg = Config.configure_scenario(id=\"s1\", task_configs=[task_cfg], frequency=Frequency.DAILY)    input_dataset_cfg_2 = Config.configure_excel_data_node(      id=\"input_excel_multi_sheet_dataset_2\",      path=EXCEL_INPUT_PATH,      has_header=True,      exposed_type=Row,      sheet_name=SHEET_NAMES,  )  output_dataset_cfg_2 = Config.configure_excel_data_node(      id=\"output_excel_multi_sheet_dataset_2\",      path=EXCEL_OUTPUT_PATH,      has_header=True,      exposed_type=Row,      sheet_name=SHEET_NAMES,  )  task_cfg_2 = Config.configure_task(id=\"t2\", input=input_dataset_cfg_2, function=algorithm, output=output_dataset_cfg_2)  scenario_cfg_2 = Config.configure_scenario(id=\"s2\", task_configs=[task_cfg_2], frequency=Frequency.DAILY)    input_dataset_cfg_3 = Config.configure_excel_data_node(      id=\"input_excel_multi_sheet_dataset_3\",      path=EXCEL_INPUT_PATH,      has_header=True,      exposed_type=\"numpy\",      sheet_name=SHEET_NAMES,  )  output_dataset_cfg_3 = Config.configure_excel_data_node(      id=\"output_excel_multi_sheet_dataset_3\",      path=EXCEL_OUTPUT_PATH,      has_header=True,      exposed_type=\"numpy\",      sheet_name=SHEET_NAMES,  )  task_cfg_3 = Config.configure_task(id=\"t3\", input=input_dataset_cfg_3, function=algorithm, output=output_dataset_cfg_3)  scenario_cfg_3 = Config.configure_scenario(id=\"s3\", task_configs=[task_cfg_3], frequency=Frequency.DAILY)    input_dataset_cfg_4 = Config.configure_excel_data_node(      id=\"input_excel_multi_sheet_dataset_4\",      path=EXCEL_INPUT_PATH,      has_header=True,      exposed_type=\"modin\",      sheet_name=SHEET_NAMES,  )  output_dataset_cfg_4 = Config.configure_excel_data_node(      id=\"output_excel_multi_sheet_dataset_4\",      path=EXCEL_OUTPUT_PATH,      has_header=True,      exposed_type=\"modin\",      sheet_name=SHEET_NAMES,  )  task_cfg_4 = Config.configure_task(id=\"t4\", input=input_dataset_cfg_4, function=algorithm, output=output_dataset_cfg_4)  scenario_cfg_4 = Config.configure_scenario(id=\"s4\", task_configs=[task_cfg_4], frequency=Frequency.DAILY) "}
{"text": "from .algorithms import *  from .config import * "}
{"text": "import pandas as pd      def algorithm(df: pd.DataFrame) -> pd.DataFrame:      return df "}
{"text": "import dataclasses    from taipy.config.common.frequency import Frequency  from taipy.config.config import Config    from .algorithms import algorithm    EXCEL_SINGLE_SHEET_INPUT_PATH = \"tests/shared_test_cases/single_excel_sheet/input_1000.xlsx\"  EXCEL_SINGLE_SHEET_OUTPUT_PATH = \"tests/shared_test_cases/single_excel_sheet/output_1000.xlsx\"  ROW_COUNT = 1000  SHEET_NAME = \"Sheet1\"      @dataclasses.dataclass  class Row:      id: int      age: int      rating: float        def __post_init__(self):          for field in dataclasses.fields(self):              value = getattr(self, field.name)              if not isinstance(value, field.type):                  setattr(self, field.name, field.type(value))      Config.unblock_update()    input_dataset_cfg_1 = Config.configure_excel_data_node(      id=\"input_excel_single_sheet_dataset_1\", path=EXCEL_SINGLE_SHEET_INPUT_PATH, has_header=True, sheet_name=SHEET_NAME  )  output_dataset_cfg_1 = Config.configure_excel_data_node(      id=\"output_excel_single_sheet_dataset_1\",      path=EXCEL_SINGLE_SHEET_OUTPUT_PATH,      has_header=True,      sheet_name=SHEET_NAME,  )  task_cfg = Config.configure_task(id=\"t1\", input=input_dataset_cfg_1, function=algorithm, output=output_dataset_cfg_1)  scenario_cfg = Config.configure_scenario(id=\"s1\", task_configs=[task_cfg], frequency=Frequency.DAILY)    input_dataset_cfg_2 = Config.configure_excel_data_node(      id=\"input_excel_single_sheet_dataset_2\",      path=EXCEL_SINGLE_SHEET_INPUT_PATH,      has_header=True,      exposed_type=Row,      sheet_name=SHEET_NAME,  )  output_dataset_cfg_2 = Config.configure_excel_data_node(      id=\"output_excel_single_sheet_dataset_2\",      path=EXCEL_SINGLE_SHEET_OUTPUT_PATH,      has_header=True,      exposed_type=Row,      sheet_name=SHEET_NAME,  )  task_cfg_2 = Config.configure_task(id=\"t2\", input=input_dataset_cfg_2, function=algorithm, output=output_dataset_cfg_2)  scenario_cfg_2 = Config.configure_scenario(id=\"s2\", task_configs=[task_cfg_2], frequency=Frequency.DAILY)    input_dataset_cfg_3 = Config.configure_excel_data_node(      id=\"input_excel_single_sheet_dataset_3\",      path=EXCEL_SINGLE_SHEET_INPUT_PATH,      has_header=True,      exposed_type=\"numpy\",      sheet_name=SHEET_NAME,  )  output_dataset_cfg_3 = Config.configure_excel_data_node(      id=\"output_excel_single_sheet_dataset_3\",      path=EXCEL_SINGLE_SHEET_OUTPUT_PATH,      has_header=True,      exposed_type=\"numpy\",      sheet_name=SHEET_NAME,  )  task_cfg_3 = Config.configure_task(id=\"t3\", input=input_dataset_cfg_3, function=algorithm, output=output_dataset_cfg_3)  scenario_cfg_3 = Config.configure_scenario(id=\"s3\", task_configs=[task_cfg_3], frequency=Frequency.DAILY)    input_dataset_cfg_4 = Config.configure_excel_data_node(      id=\"input_excel_single_sheet_dataset_4\",      path=EXCEL_SINGLE_SHEET_INPUT_PATH,      has_header=True,      exposed_type=\"modin\",      sheet_name=SHEET_NAME,  )  output_dataset_cfg_4 = Config.configure_excel_data_node(      id=\"output_excel_single_sheet_dataset_4\",      path=EXCEL_SINGLE_SHEET_OUTPUT_PATH,      has_header=True,      exposed_type=\"modin\",      sheet_name=SHEET_NAME,  )  task_cfg_4 = Config.configure_task(id=\"t4\", input=input_dataset_cfg_4, function=algorithm, output=output_dataset_cfg_4)  scenario_cfg_4 = Config.configure_scenario(id=\"s4\", task_configs=[task_cfg_4], frequency=Frequency.DAILY) "}
{"text": "from .algorithms import *  from .config import * "}
{"text": "  def algorithm(data):      return data "}
{"text": "import dataclasses    from taipy.config.common.frequency import Frequency  from taipy.config.config import Config    from .algorithms import algorithm    PICKLE_DICT_INPUT_PATH = \"tests/shared_test_cases/pickle_files/input_dict_1000.p\"  PICKLE_DICT_OUTPUT_PATH = \"tests/shared_test_cases/pickle_files/output_dict_1000.p\"  PICKLE_LIST_INPUT_PATH = \"tests/shared_test_cases/pickle_files/input_object_1000.p\"  PICKLE_LIST_OUTPUT_PATH = \"tests/shared_test_cases/pickle_files/output_object_1000.p\"  ROW_COUNT = 1000      @dataclasses.dataclass  class Row:      id: int      age: int      rating: float      Config.unblock_update()    input_dataset_cfg_1 = Config.configure_pickle_data_node(id=\"input_pickle_dataset_1\", path=PICKLE_DICT_INPUT_PATH)  output_dataset_cfg_1 = Config.configure_pickle_data_node(id=\"output_pickle_dataset_1\", path=PICKLE_DICT_OUTPUT_PATH)  task_cfg_1 = Config.configure_task(id=\"t1\", input=input_dataset_cfg_1, function=algorithm, output=output_dataset_cfg_1)  scenario_cfg_1 = Config.configure_scenario(id=\"s1\", task_configs=[task_cfg_1], frequency=Frequency.DAILY)    input_dataset_cfg_2 = Config.configure_pickle_data_node(id=\"input_pickle_dataset_2\", path=PICKLE_LIST_INPUT_PATH)  output_dataset_cfg_2 = Config.configure_pickle_data_node(id=\"output_pickle_dataset_2\", path=PICKLE_LIST_OUTPUT_PATH)  task_cfg_2 = Config.configure_task(id=\"t2\", input=input_dataset_cfg_2, function=algorithm, output=output_dataset_cfg_2)  scenario_cfg_2 = Config.configure_scenario(id=\"s2\", task_configs=[task_cfg_2], frequency=Frequency.DAILY) "}
{"text": "from .algorithms import *  from .config import *  from .utils import * "}
{"text": "import pickle  import random    from tests.shared_test_cases.pickle_files import Row      def gen_list_of_dict_input_pickle(path, n):      data = []      for i in range(n):          row = {\"id\": i + 1, \"age\": random.randint(10, 99), \"rating\": round(random.uniform(0, 10), 2)}          data.append(row)      pickle.dump(data, open(path, \"wb\"))      def gen_list_of_objects_input_pickle(path, n):      data = []      for i in range(n):          row = Row(i + 1, random.randint(10, 99), round(random.uniform(0, 10), 2))          data.append(row)      pickle.dump(data, open(path, \"wb\")) "}
{"text": "  def algorithm(data):      return data "}
{"text": "from taipy.config.common.frequency import Frequency  from taipy.config.config import Config    from .algorithms import algorithm  from .utils import RowDecoder, RowEncoder    JSON_DICT_INPUT_PATH = \"tests/shared_test_cases/json_files/input_dict_1000.json\"  JSON_DICT_OUTPUT_PATH = \"tests/shared_test_cases/json_files/output_dict_1000.json\"  JSON_OBJECT_INPUT_PATH = \"tests/shared_test_cases/json_files/input_object_1000.json\"  JSON_OBJECT_OUTPUT_PATH = \"tests/shared_test_cases/json_files/output_object_1000.json\"  ROW_COUNT = 1000    Config.unblock_update()    input_dataset_cfg_1 = Config.configure_json_data_node(id=\"input_json_dataset_1\", path=JSON_DICT_INPUT_PATH)  output_dataset_cfg_1 = Config.configure_json_data_node(id=\"output_json_dataset_1\", path=JSON_DICT_OUTPUT_PATH)  task_cfg_1 = Config.configure_task(id=\"t1\", input=input_dataset_cfg_1, function=algorithm, output=output_dataset_cfg_1)  scenario_cfg_1 = Config.configure_scenario(id=\"s1\", task_configs=[task_cfg_1], frequency=Frequency.DAILY)    input_dataset_cfg_2 = Config.configure_json_data_node(      id=\"input_json_dataset_2\", path=JSON_OBJECT_INPUT_PATH, decoder=RowDecoder  )  output_dataset_cfg_2 = Config.configure_json_data_node(      id=\"output_json_dataset_2\", path=JSON_OBJECT_OUTPUT_PATH, encoder=RowEncoder, decoder=RowDecoder  )  task_cfg_2 = Config.configure_task(id=\"t2\", input=input_dataset_cfg_2, function=algorithm, output=output_dataset_cfg_2)  scenario_cfg_2 = Config.configure_scenario(id=\"s2\", task_configs=[task_cfg_2], frequency=Frequency.DAILY) "}
{"text": "from .algorithms import *  from .config import *  from .utils import * "}
{"text": "import json  import random  import time  from dataclasses import dataclass      @dataclass  class Row:      id: int      age: int      rating: float      class RowEncoder(json.JSONEncoder):      def default(self, obj):          if isinstance(obj, Row):              return {\"id\": obj.id, \"age\": obj.age, \"rating\": obj.rating, \"__type__\": \"Row\"}          return json.JSONEncoder.default(self, obj)      class RowDecoder(json.JSONDecoder):      def __init__(self, *args, **kwargs):          json.JSONDecoder.__init__(self, object_hook=self.object_hook, *args, **kwargs)        def object_hook(self, d):          if \"__type__\" in d and d[\"__type__\"] == \"Row\":              return Row(d[\"id\"], d[\"age\"], d[\"rating\"])      def timer(f):      def wrapper(*args, **kwargs):          print(f\"\u23f3 {f.__name__}\")          start = time.time()          result = f(*args, **kwargs)          end = time.time()          elapsed = round(end - start, 4)          print(f\"\\t\u2714\ufe0f {elapsed} seconds\")          return result        return wrapper      def get_list_of_dicts(n):      data = []      for i in range(n):          row = {\"id\": i + 1, \"age\": random.randint(10, 99), \"rating\": round(random.uniform(0, 10), 2)}          data.append(row)      return data      def get_list_of_objects(n):      data = []      for i in range(n):          row = Row(i + 1, random.randint(10, 99), round(random.uniform(0, 10), 2))          data.append(row)      return data "}
{"text": "from unittest.mock import patch    import taipy.core.taipy as tp  from taipy import Config  from taipy.core import Core  from taipy.core.config import JobConfig  from taipy.core.job.status import Status    from tests.utils import assert_true_after_time      def mult_by_2(a):      return a      def build_skipped_jobs_config():      input_config = Config.configure_data_node(id=\"input\")      intermediate_config = Config.configure_data_node(id=\"intermediate\")      output_config = Config.configure_data_node(id=\"output\")      task_config_1 = Config.configure_task(\"first\", mult_by_2, input_config, intermediate_config, skippable=True)      task_config_2 = Config.configure_task(\"second\", mult_by_2, intermediate_config, output_config, skippable=True)      scenario_config = Config.configure_scenario(\"scenario\", task_configs=[task_config_1, task_config_2])      return scenario_config      class TestSkipJobs:      @staticmethod      def __test():          scenario_config = build_skipped_jobs_config()          with patch(\"sys.argv\", [\"prog\"]):              Core().run()          scenario = tp.create_scenario(scenario_config)          scenario.input.write(2)          scenario.submit()          assert len(tp.get_jobs()) == 2          for job in tp.get_jobs():              assert_true_after_time(job.is_completed, msg=f\"job {job.id} is not completed. Status: {job.status}\")          scenario.submit()          assert len(tp.get_jobs()) == 4          skipped = []          for job in tp.get_jobs():              if job.status != Status.COMPLETED:                  assert_true_after_time(job.is_skipped, msg=f\"job {job.id} is not skipped. Status: {job.status}\")                  skipped.append(job)          assert len(skipped) == 2        def test_development_fs_repo(self):          self.__test()        def test_development_sql_repo(self, tmp_sqlite):          Config.configure_global_app(repository_type=\"sql\", repository_properties={\"db_location\": tmp_sqlite})          self.__test()        def test_standalone_fs_repo(self):          Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)          self.__test()        def test_standalone_sql_repo(self, tmp_sqlite):          Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)          Config.configure_global_app(repository_type=\"sql\", repository_properties={\"db_location\": tmp_sqlite})          self.__test() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  import os  from unittest.mock import patch    import pandas as pd  import taipy.core.taipy as tp  from taipy import Config  from taipy.core import Core  from taipy.core.config import JobConfig    from tests.test_complex.utils.algos import average  from tests.test_complex.utils.config_builders import build_complex_config, build_complex_required_file_paths  from tests.utils import assert_true_after_time      class TestComplexApp:      @staticmethod      def __test():          _, _, csv_path_sum, excel_path_sum, excel_path_out, csv_path_out = build_complex_required_file_paths()          scenario_config = build_complex_config()          with patch(\"sys.argv\", [\"prog\"]):              Core().run(force_restart=True)          scenario = tp.create_scenario(scenario_config)          jobs = tp.submit(scenario)          for job in jobs:              assert_true_after_time(job.is_completed, msg=f\"job {job.id} is not completed. Status: {job.status}.\")            csv_sum_res = pd.read_csv(csv_path_sum)          excel_sum_res = pd.read_excel(excel_path_sum)          csv_out = pd.read_csv(csv_path_out)          excel_out = pd.read_excel(excel_path_out)          assert csv_sum_res.to_numpy().flatten().tolist() == [i * 20 for i in range(1, 11)]          assert excel_sum_res.to_numpy().flatten().tolist() == [i * 2 for i in range(1, 11)]          assert average(csv_sum_res[\"number\"] - excel_sum_res[\"number\"]) == csv_out.to_numpy()[0]          assert average((csv_sum_res[\"number\"] - excel_sum_res[\"number\"]) * 10) == excel_out.to_numpy()[0]            for path in [csv_path_sum, excel_path_sum, csv_path_out, excel_path_out]:              os.remove(path)        def test_development_fs_repo(self):          self.__test()        def test_development_sql_repo(self, tmp_sqlite):          Config.configure_global_app(repository_type=\"sql\", repository_properties={\"db_location\": tmp_sqlite})          self.__test()        def test_standalone_fs_repo(self):          Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)          self.__test()        def test_standalone_sql_repo(self, tmp_sqlite):          Config.configure_global_app(repository_type=\"sql\", repository_properties={\"db_location\": tmp_sqlite})          Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)          self.__test() "}
{"text": "from unittest.mock import patch    import taipy.core.taipy as tp  from taipy import Config  from taipy.core import Core  from taipy.core.config import JobConfig    from tests.test_complex.utils.config_builders import build_churn_classification_config  from tests.utils import assert_true_after_time      class TestChurnClassification:      @staticmethod      def __test():          scenario_cfg = build_churn_classification_config()          with patch(\"sys.argv\", [\"prog\"]):              Core().run(force_restart=True)          scenario = tp.create_scenario(scenario_cfg)          jobs = tp.submit(scenario)          for job in jobs:              assert_true_after_time(                  job.is_completed, msg=f\"job {job.id} is not completed. Status: {job.status}.\", time=30              )        def test_development_fs_repo(self):          self.__test()        def test_development_sql_repo(self, tmp_sqlite):          Config.configure_global_app(repository_type=\"sql\", repository_properties={\"db_location\": tmp_sqlite})          self.__test()        def test_standalone_fs_repo(self):          Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)          self.__test()        def test_standalone_sql_repo(self, tmp_sqlite):          Config.configure_global_app(repository_type=\"sql\", repository_properties={\"db_location\": tmp_sqlite})          Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)          self.__test() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from taipy import Config, Core, Gui    if __name__ == \"__main__\":      core = Core()      core.run()        gui = Gui()      gui._config._handle_argparse()        print(f\"Config.core.version_number: {Config.core.version_number}\")      print(f\"Config.core.mode: {Config.core.mode}\")      print(f\"Config.core.force: {Config.core.force}\")      print(f\"Config.gui_config.host: {gui._config.config.get('host', None)}\")      print(f\"Config.gui_config.port: {gui._config.config.get('port', None)}\")      print(f\"Config.gui_config.debug: {gui._config.config.get('debug', None)}\")      print(f\"Config.gui_config.use_reloader: {gui._config.config.get('use_reloader', None)}\")      print(f\"Config.gui_config.ngrok_token: {gui._config.config.get('ngrok_token', None)}\")      print(f\"Config.gui_config.webapp_path: {gui._config.config.get('webapp_path', None)}\") "}
{"text": "import argparse    from taipy import Config, Core, Gui    if __name__ == \"__main__\":      parser = argparse.ArgumentParser()      parser.add_argument(\"--mode\", dest=\"mode\", type=str, default=\"training\")      parser.add_argument(\"--force\", type=str, default=\"no\")      parser.add_argument(\"--host\", dest=\"host\", type=str, default=\"user_default_host.com\")      parser.add_argument(\"--port\", type=int, default=8080)      parser.add_argument(\"--non-conflict-arg\", type=str, default=\"\")        core = Core()      core.run()        gui = Gui()      gui._config._handle_argparse()        user_args, _ = parser.parse_known_args()        print(f\"Config.core.mode: {Config.core.mode}\")      print(f\"User provided mode: {user_args.mode}\")      print(f\"Config.core.force: {Config.core.force}\")      print(f\"User provided force: {user_args.force}\")      print(f\"Config.gui_config.host: {gui._config.config.get('host', None)}\")      print(f\"User provided host: {user_args.host}\")      print(f\"Config.gui_config.port: {gui._config.config.get('port', None)}\")      print(f\"User provided port: {user_args.port}\")      print(f\"User provided non-conflict-arg: {user_args.non_conflict_arg}\") "}
{"text": "import taipy as tp  from taipy.gui import Gui, notify  from taipy.config import Config    import dask_ml.datasets  import dask_ml.cluster    import pandas as pd    n_clusters = 3  data = dask_ml.datasets.make_blobs(      n_samples=1000000, chunks=1000000, random_state=0, centers=n_clusters  )  X, _ = data  km = dask_ml.cluster.KMeans(n_clusters=n_clusters)  km.fit(X)  visual_data = pd.DataFrame(      {\"x\": X[::1000, 0], \"y\": X[::1000, 1], \"color\": km.labels_[::1000]}  )    Config.load(\"config.toml\")    scenario_object = Config.scenarios[\"scenario\"]      def on_button(state):      notify(state, \"info\", \"Running K-Means...\")      scenario = tp.create_scenario(scenario_object)      scenario.centers.write(state.n_clusters)      scenario.n_clusters.write(state.n_clusters)      tp.submit(scenario)      state.X = scenario.dataset.read()      state.km = scenario.km.read()      state.visual_data = pd.DataFrame(          {              \"x\": state.X[::1000, 0],              \"y\": state.X[::1000, 1],              \"color\": state.km.labels_[::1000],          }      )      notify(state, \"success\", \"Done!\")      page = \"\"\"  # Scaling K-Means with **Dask**{: .color-secondary} and **Taipy**{: .color-primary}    Number of clusters:    <|{n_clusters}|slider|min=1|max=10|>    <|Run K-Means|button|on_action=on_button|>    <|{visual_data}|chart|mode=markers|x=x|y=y|color=color|rebuild|>  \"\"\"    tp.Core().run()  Gui(page).run() "}
{"text": "import dask  import dask_ml.datasets      def generate_data(centers: int):      \"\"\"      Generates synthetic data for clustering.        Args:          - centers (int): number of clusters to generate        Returns:          - X (dask.array): array of shape (n_samples, n_features)      \"\"\"      X, _ = dask_ml.datasets.make_blobs(          n_samples=1000000, chunks=1000000, random_state=0, centers=centers      )      return X.persist()      def fit(X: dask.array, n_clusters: int):      \"\"\"      Fit a k-means clustering model.        Args:          - X (dask.array): array of shape (n_samples, n_features)          - n_clusters (int): number of clusters to fit        Returns:          - km (dask_ml.cluster.KMeans): k-means clustering model      \"\"\"      km = dask_ml.cluster.KMeans(n_clusters=n_clusters)      km.fit(X)      return km "}
{"text": "#!/usr/bin/env python    \"\"\"The setup script.\"\"\"    import json  import os  from pathlib import Path    from setuptools import find_namespace_packages, find_packages, setup  from setuptools.command.build_py import build_py    readme = Path(\"README.md\").read_text()    with open(f\"src{os.sep}taipy{os.sep}gui{os.sep}version.json\") as version_file:      version = json.load(version_file)      version_string = f'{version.get(\"major\", 0)}.{version.get(\"minor\", 0)}.{version.get(\"patch\", 0)}'      if vext := version.get(\"ext\"):          version_string = f\"{version_string}.{vext}\"    requirements = [      \"flask>=3.0.0,<3.1\",      \"flask-cors>=4.0.0,<5.0\",      \"flask-socketio>=5.3.6,<6.0\",      \"markdown>=3.4.4,<4.0\",      \"pandas>=2.0.0,<3.0\",      \"python-dotenv>=1.0.0,<1.1\",      \"pytz>=2021.3,<2022.2\",      \"tzlocal>=3.0,<5.0\",      \"backports.zoneinfo>=0.2.1,<0.3;python_version<'3.9'\",      \"gevent>=23.7.0,<24.0\",      \"gevent-websocket>=0.10.1,<0.11\",      \"kthread>=0.2.3,<0.3\",      \"taipy-config@git+https://git@github.com/Avaiga/taipy-config.git@develop\",      \"gitignore-parser>=0.1,<0.2\",      \"simple-websocket>=0.10.1,<1.0\",      \"twisted>=23.8.0,<24.0\",  ]    test_requirements = [\"pytest>=3.8\"]    extras_require = {      \"ngrok\": [\"pyngrok>=5.1,<6.0\"],      \"image\": [          \"python-magic>=0.4.24,<0.5;platform_system!='Windows'\",          \"python-magic-bin>=0.4.14,<0.5;platform_system=='Windows'\",      ],      \"arrow\": [\"pyarrow>=10.0.1,<11.0\"],  }      def _build_webapp():      already_exists = Path(\"./src/taipy/gui/webapp/index.html\").exists()      if not already_exists:          os.system(\"cd frontend/taipy-gui/dom && npm ci\")          os.system(\"cd frontend/taipy-gui && npm ci --omit=optional && npm run build\")      class NPMInstall(build_py):      def run(self):          _build_webapp()          build_py.run(self)      setup(      author=\"Avaiga\",      author_email=\"dev@taipy.io\",      python_requires=\">=3.8\",      classifiers=[          \"Intended Audience :: Developers\",          \"License :: OSI Approved :: Apache Software License\",          \"Natural Language :: English\",          \"Programming Language :: Python :: 3\",          \"Programming Language :: Python :: 3.8\",          \"Programming Language :: Python :: 3.9\",          \"Programming Language :: Python :: 3.10\",          \"Programming Language :: Python :: 3.11\",      ],      description=\"Low-code library to create graphical user interfaces on the Web for your Python applications.\",      long_description=readme,      long_description_content_type=\"text/markdown\",      install_requires=requirements,      license=\"Apache License 2.0\",      include_package_data=True,      keywords=\"taipy-gui\",      name=\"taipy-gui\",      package_dir={\"\": \"src\"},      packages=find_namespace_packages(where=\"src\") + find_packages(include=[\"taipy\", \"taipy.gui\", \"taipy.gui.*\"]),      test_suite=\"tests\",      tests_require=test_requirements,      url=\"https://github.com/avaiga/taipy-gui\",      version=version_string,      zip_safe=False,      extras_require=extras_require,      cmdclass={\"build_py\": NPMInstall},  ) "}
{"text": "# ############################################################  # Generate Python interface definition files  # ############################################################  import json  import os  import typing as t    # ############################################################  # Generate gui pyi file (gui/gui.pyi)  # ############################################################  gui_py_file = \"./src/taipy/gui/gui.py\"  gui_pyi_file = gui_py_file + \"i\"    os.system(f\"pipenv run stubgen {gui_py_file} --no-import --parse-only --export-less -o ./\")    from src.taipy.gui.config import Config    gui_config = \"\".join(      f\", {k}: {v.__name__} = ...\"      if \"<class\" in str(v)      else f\", {k}: {str(v).replace('typing', 't').replace('src.taipy.gui.config.', '')} = ...\"      for k, v in Config.__annotations__.items()  )    replaced_content = \"\"  with open(gui_pyi_file, \"r\") as file:      for line in file:          if \"def run(\" in line:              line = line.replace(                  \", run_server: bool = ..., run_in_thread: bool = ..., async_mode: str = ..., **kwargs\", gui_config              )          replaced_content = replaced_content + line    with open(gui_pyi_file, \"w\") as write_file:      write_file.write(replaced_content)    # ############################################################  # Generate Page Builder pyi file (gui/builder/__init__.pyi)  # ############################################################  builder_py_file = \"./src/taipy/gui/builder/__init__.py\"  builder_pyi_file = builder_py_file + \"i\"  with open(\"./src/taipy/gui/viselements.json\", \"r\") as file:      viselements = json.load(file)  with open(\"./tools/builder/block.txt\", \"r\") as file:      block_template = file.read()  with open(\"./tools/builder/control.txt\", \"r\") as file:      control_template = file.read()    os.system(f\"pipenv run stubgen {builder_py_file} --no-import --parse-only --export-less -o ./\")    with open(builder_pyi_file, \"a\") as file:      file.write(\"from ._element import _Element, _Block\\n\")      def get_properties(element, viselements) -> t.List[t.Dict[str, t.Any]]:      properties = element[\"properties\"]      if \"inherits\" not in element:          return properties      for inherit in element[\"inherits\"]:          inherit_element = next((e for e in viselements[\"undocumented\"] if e[0] == inherit), None)          if inherit_element is None:              inherit_element = next((e for e in viselements[\"blocks\"] if e[0] == inherit), None)          if inherit_element is None:              inherit_element = next((e for e in viselements[\"controls\"] if e[0] == inherit), None)          if inherit_element is None:              raise RuntimeError(f\"Can't find element with name {inherit}\")          properties += get_properties(inherit_element[1], viselements)      return properties      def build_doc(element: t.Dict[str, t.Any]):      if \"doc\" not in element:          return \"\"      doc = str(element[\"doc\"]).replace(\"\\n\", f'\\n{16*\" \"}')      return f\"{element['name']} ({element['type']}): {doc} {'(default: '+element['default_value'] + ')' if 'default_value' in element else ''}\"      for control_element in viselements[\"controls\"]:      name = control_element[0]      property_list = []      property_names = []      for property in get_properties(control_element[1], viselements):          if property[\"name\"] not in property_names and \"[\" not in property[\"name\"]:              property_list.append(property)              property_names.append(property[\"name\"])      properties = \", \".join([f\"{p} = ...\" for p in property_names])      doc_arguments = f\"\\n{12*' '}\".join([build_doc(p) for p in property_list])      # append properties to __init__.pyi      with open(builder_pyi_file, \"a\") as file:          file.write(              control_template.replace(\"{{name}}\", name)              .replace(\"{{properties}}\", properties)              .replace(\"{{doc_arguments}}\", doc_arguments)          )    for block_element in viselements[\"blocks\"]:      name = block_element[0]      property_list = []      property_names = []      for property in get_properties(block_element[1], viselements):          if property[\"name\"] not in property_names and \"[\" not in property[\"name\"]:              property_list.append(property)              property_names.append(property[\"name\"])      properties = \", \".join([f\"{p} = ...\" for p in property_names])      doc_arguments = f\"{8*' '}\".join([build_doc(p) for p in property_list])      # append properties to __init__.pyi      with open(builder_pyi_file, \"a\") as file:          file.write(              block_template.replace(\"{{name}}\", name)              .replace(\"{{properties}}\", properties)              .replace(\"{{doc_arguments}}\", doc_arguments)          )    os.system(f\"pipenv run isort {gui_pyi_file}\")  os.system(f\"pipenv run black {gui_pyi_file}\")  os.system(f\"pipenv run isort {builder_pyi_file}\")  os.system(f\"pipenv run black {builder_pyi_file}\") "}
{"text": "import pytest      def pytest_addoption(parser):      parser.addoption(\"--e2e-base-url\", action=\"store\", default=\"/\", help=\"base url for e2e testing\")      parser.addoption(\"--e2e-port\", action=\"store\", default=\"5000\", help=\"port for e2e testing\")      @pytest.fixture(scope=\"session\")  def e2e_base_url(request):      return request.config.getoption(\"--e2e-base-url\")      @pytest.fixture(scope=\"session\")  def e2e_port(request):      return request.config.getoption(\"--e2e-port\") "}
{"text": "\"\"\"Unit test package for taipy.\"\"\" "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import os  import sys  from importlib.util import find_spec  from pathlib import Path    import pandas as pd  # type: ignore  import pytest  from flask import Flask, g      def pytest_configure(config):      if (find_spec(\"src\") and find_spec(\"src.taipy\")) and (not find_spec(\"taipy\") or not find_spec(\"taipy.gui\")):          import src.taipy.gui          import src.taipy.gui._renderers.builder          import src.taipy.gui._warnings          import src.taipy.gui.builder          import src.taipy.gui.data.decimator.lttb          import src.taipy.gui.data.decimator.minmax          import src.taipy.gui.data.decimator.rdp          import src.taipy.gui.data.decimator.scatter_decimator          import src.taipy.gui.data.utils          import src.taipy.gui.extension          import src.taipy.gui.utils._map_dict          import src.taipy.gui.utils._variable_directory          import src.taipy.gui.utils.expr_var_name            sys.modules[\"taipy.gui._warnings\"] = sys.modules[\"src.taipy.gui._warnings\"]          sys.modules[\"taipy.gui._renderers.builder\"] = sys.modules[\"src.taipy.gui._renderers.builder\"]          sys.modules[\"taipy.gui.utils._variable_directory\"] = sys.modules[\"src.taipy.gui.utils._variable_directory\"]          sys.modules[\"taipy.gui.utils.expr_var_name\"] = sys.modules[\"src.taipy.gui.utils.expr_var_name\"]          sys.modules[\"taipy.gui.utils._map_dict\"] = sys.modules[\"src.taipy.gui.utils._map_dict\"]          sys.modules[\"taipy.gui.extension\"] = sys.modules[\"src.taipy.gui.extension\"]          sys.modules[\"taipy.gui.data.utils\"] = sys.modules[\"src.taipy.gui.data.utils\"]          sys.modules[\"taipy.gui.data.decimator.lttb\"] = sys.modules[\"src.taipy.gui.data.decimator.lttb\"]          sys.modules[\"taipy.gui.data.decimator.rdp\"] = sys.modules[\"src.taipy.gui.data.decimator.rdp\"]          sys.modules[\"taipy.gui.data.decimator.minmax\"] = sys.modules[\"src.taipy.gui.data.decimator.minmax\"]          sys.modules[\"taipy.gui.data.decimator.scatter_decimator\"] = sys.modules[              \"src.taipy.gui.data.decimator.scatter_decimator\"          ]          sys.modules[\"taipy.gui\"] = sys.modules[\"src.taipy.gui\"]          sys.modules[\"taipy.gui.builder\"] = sys.modules[\"src.taipy.gui.builder\"]      csv = pd.read_csv(      f\"{Path(Path(__file__).parent.resolve())}{os.path.sep}current-covid-patients-hospital.csv\", parse_dates=[\"Day\"]  )  small_dataframe_data = {\"name\": [\"A\", \"B\", \"C\"], \"value\": [1, 2, 3]}      @pytest.fixture(scope=\"function\")  def csvdata():      yield csv      @pytest.fixture(scope=\"function\")  def small_dataframe():      yield small_dataframe_data      @pytest.fixture(scope=\"function\")  def gui(helpers):      from taipy.gui import Gui        gui = Gui()      yield gui      # Delete Gui instance and state of some classes after each test      gui.stop()      helpers.test_cleanup()      @pytest.fixture  def helpers():      from .helpers import Helpers        return Helpers      @pytest.fixture  def test_client():      flask_app = Flask(\"Test App\")        # Create a test client using the Flask application configured for testing      with flask_app.test_client() as testing_client:          # Establish an application context          with flask_app.app_context():              g.client_id = \"test client id\"              yield testing_client  # this is where the testing happens! "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import inspect    from taipy.gui import Gui, Html      def test_simple_html(gui: Gui, helpers):      # html_string = \"<html><head></head><body><h1>test</h1><taipy:field value=\\\"test\\\"/></body></html>\"      html_string = \"<html><head></head><body><h1>test</h1></body></html>\"      gui._set_frame(inspect.currentframe())      gui.add_page(\"test\", Html(html_string))      gui.run(run_server=False)      client = gui._server.test_client()      jsx = client.get(\"/taipy-jsx/test\").json[\"jsx\"]      assert jsx == \"<h1>test</h1>\" "}
{"text": "import pytest    from taipy.gui import Gui      def test_invalid_control_name(gui: Gui, helpers):      md_string = \"<|invalid|invalid|>\"      expected_list = [\"INVALID SYNTAX - Control is 'invalid'\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_value_to_negated_property(gui: Gui, helpers):      md_string = \"<|button|not active=true|>\"      expected_list = [\"<Button\", \"active={false}\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_invalid_property_value(gui: Gui, helpers):      md_string = \"<|button|let's try that!|>\"      expected_list = [\"<Button\", 'label=\"&lt;Empty&gt;\"']      helpers.test_control_md(gui, md_string, expected_list)      def test_unclosed_block(gui: Gui, helpers):      md_string = \"<|\"      expected_list = [\"<Part\", \"</Part>\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_opening_unknown_block(gui: Gui, helpers):      md_string = \"<|unknown\"      expected_list = [\"<Part\", 'className=\"unknown\"']      helpers.test_control_md(gui, md_string, expected_list)      def test_closing_unknown_block(gui: Gui, helpers):      md_string = \"|>\"      expected_list = [\"<div>\", \"No matching opened tag\", \"</div>\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_md_link(gui: Gui, helpers):      md_string = \"[content](link)\"      expected_list = [\"<a\", 'href=\"link\"', \"content</a>\"]      helpers.test_control_md(gui, md_string, expected_list) "}
{"text": "import pytest    from taipy.gui.utils._bindings import _Bindings      def test_exception_binding_twice(gui, test_client):      bind = _Bindings(gui)      bind._new_scopes()      bind._bind(\"x\", 10)      with pytest.raises(ValueError):          bind._bind(\"x\", 10)      def test_exception_binding_invalid_name(gui):      bind = _Bindings(gui)      bind._new_scopes()      with pytest.raises(ValueError):          bind._bind(\"invalid identifier\", 10) "}
{"text": "from email import message    import pytest    from taipy.gui._page import _Page      def test_exception_page(gui):      page = _Page()      page._route = \"page1\"      with pytest.raises(RuntimeError, match=\"Can't render page page1: no renderer found\"):          page.render(gui) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import os  import tempfile  from unittest.mock import patch    import pytest    from taipy.config import Config  from taipy.config._config import _Config  from taipy.config._serializer._toml_serializer import _TomlSerializer  from taipy.config.checker._checker import _Checker  from taipy.config.checker.issue_collector import IssueCollector  from taipy.gui import Gui      class NamedTemporaryFile:      def __init__(self, content=None):          with tempfile.NamedTemporaryFile(\"w\", delete=False) as fd:              if content:                  fd.write(content)              self.filename = fd.name        def read(self):          with open(self.filename, \"r\") as fp:              return fp.read()        def __del__(self):          os.unlink(self.filename)      def init_config():      Config.unblock_update()      Config._default_config = _Config()._default_config()      Config._python_config = _Config()      Config._file_config = None      Config._env_file_config = None      Config._applied_config = _Config._default_config()      Config._collector = IssueCollector()      Config._serializer = _TomlSerializer()      _Checker._checkers = []        from taipy.config import _inject_section      from taipy.gui._default_config import default_config      from taipy.gui._gui_section import _GuiSection        _inject_section(          _GuiSection,          \"gui_config\",          _GuiSection(property_list=list(default_config)),          [(\"configure_gui\", _GuiSection._configure)],          add_to_unconflicted_sections=True,      )      @pytest.fixture(scope=\"function\", autouse=True)  def cleanup_test(helpers):      init_config()      helpers.test_cleanup()      yield      init_config()      helpers.test_cleanup()      def test_gui_service_arguments_hierarchy():      # Test default configuration      gui = Gui()      gui.run(run_server=False)      service_config = gui._config.config      assert not service_config[\"allow_unsafe_werkzeug\"]      assert service_config[\"async_mode\"] == \"gevent\"      assert service_config[\"change_delay\"] is None      assert service_config[\"chart_dark_template\"] is None      assert service_config[\"dark_mode\"]      assert service_config[\"dark_theme\"] is None      assert not service_config[\"debug\"]      assert not service_config[\"extended_status\"]      assert service_config[\"favicon\"] is None      assert not service_config[\"flask_log\"]      assert service_config[\"host\"] == \"127.0.0.1\"      assert service_config[\"light_theme\"] is None      assert service_config[\"margin\"] is None      assert service_config[\"ngrok_token\"] == \"\"      assert service_config[\"notification_duration\"] == 3000      assert service_config[\"propagate\"]      assert service_config[\"run_browser\"]      assert not service_config[\"run_in_thread\"]      assert not service_config[\"run_server\"]      assert not service_config[\"single_client\"]      assert not service_config[\"system_notification\"]      assert service_config[\"theme\"] is None      assert service_config[\"time_zone\"] is None      assert service_config[\"title\"] is None      assert service_config[\"upload_folder\"] is None      assert not service_config[\"use_arrow\"]      assert not service_config[\"use_reloader\"]      assert service_config[\"watermark\"] == \"Taipy inside\"      assert service_config[\"webapp_path\"] is None      assert service_config[\"port\"] == 5000      gui.stop()        # Override default configuration by explicit defined arguments in Gui.run()      gui = Gui()      gui.run(run_server=False, watermark=\"\", host=\"my_host\", port=5001)      service_config = gui._config.config      assert service_config[\"watermark\"] == \"\"      assert service_config[\"host\"] == \"my_host\"      assert service_config[\"port\"] == 5001      gui.stop()        # Override Gui.run() arguments by explicit defined arguments in Config.configure_gui()      Config.configure_gui(dark_mode=False, host=\"my_2nd_host\", port=5002)      gui = Gui()      gui.run(run_server=False, watermark=\"\", host=\"my_host\", port=5001)      service_config = gui._config.config      assert not service_config[\"dark_mode\"]      assert service_config[\"host\"] == \"my_2nd_host\"      assert service_config[\"watermark\"] == \"\"      assert service_config[\"port\"] == 5002      gui.stop()        # Override Config.configure_gui() arguments by loading a TOML file with [gui] section      toml_config = NamedTemporaryFile(          content=\"\"\"  [TAIPY]    [gui]  host = \"my_3rd_host\"  port = 5003  use_reloader = \"true:bool\"      \"\"\"      )      Config.load(toml_config.filename)      gui = Gui()      gui.run(run_server=False, host=\"my_host\", port=5001)      service_config = gui._config.config      assert service_config[\"host\"] == \"my_3rd_host\"      assert service_config[\"port\"] == 5003      assert service_config[\"use_reloader\"]      gui.stop()        # Override TOML configuration file with CLI arguments      with patch(\"sys.argv\", [\"prog\", \"--host\", \"my_4th_host\", \"--port\", \"5004\", \"--no-reloader\", \"--debug\"]):          gui = Gui()          gui.run(run_server=False, host=\"my_host\", port=5001)          service_config = gui._config.config          assert service_config[\"host\"] == \"my_4th_host\"          assert service_config[\"port\"] == 5004          assert not service_config[\"use_reloader\"]          assert service_config[\"debug\"]          gui.stop()      def test_clean_config():      gui_config = Config.configure_gui(dark_mode=False)        assert Config.gui_config is gui_config        gui_config._clean()        # Check if the instance before and after _clean() is the same      assert Config.gui_config is gui_config        assert gui_config.dark_mode is None      assert gui_config.properties == {} "}
{"text": "import inspect  import warnings    import pytest    from taipy.gui import Gui      def test_no_ignore_file(gui: Gui):      with warnings.catch_warnings(record=True):          gui._set_frame(inspect.currentframe())          gui.run(run_server=False)          client = gui._server.test_client()          response = client.get(\"/resource.txt\")          assert (              response.status_code == 200          ), f\"file resource.txt request status should be 200 but is {response.status_code}\" "}
{"text": "import inspect  import warnings    import pytest    from taipy.gui import Gui      def test_ignore_file_found(gui: Gui):      with warnings.catch_warnings(record=True):          gui._set_frame(inspect.currentframe())          gui.run(run_server=False)          client = gui._server.test_client()          response = client.get(\"/resource.txt\")          assert (              response.status_code == 404          ), f\"file resource.txt request status should be 404 but is {response.status_code}\"      def test_ignore_file_not_found(gui: Gui):      with warnings.catch_warnings(record=True):          gui._set_frame(inspect.currentframe())          gui.run(run_server=False)          client = gui._server.test_client()          response = client.get(\"/resource2.txt\")          assert (              response.status_code == 200          ), f\"file resource2.txt request status should be 200 but is {response.status_code}\" "}
{"text": "import inspect  import time  from urllib.request import urlopen    from taipy.gui import Gui      # this hangs in github  def test_run_thread(gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      gui.add_page(\"page1\", \"# first page\")      gui.run(run_in_thread=True, run_browser=False)      while not helpers.port_check():          time.sleep(0.1)      assert \">first page</h1>\" in urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\").read().decode(\"utf-8\")      gui.stop()      while helpers.port_check():          time.sleep(0.1)      gui.run(run_in_thread=True, run_browser=False)      while not helpers.port_check():          time.sleep(0.1)      assert \">first page</h1>\" in urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\").read().decode(\"utf-8\") "}
{"text": "import pytest    from taipy.gui import Gui      def test_add_shared_variables(gui: Gui):      Gui.add_shared_variable(\"var1\", \"var2\")      assert isinstance(gui._Gui__shared_variables, list)      assert len(gui._Gui__shared_variables) == 2        Gui.add_shared_variables(\"var1\", \"var2\")      assert len(gui._Gui__shared_variables) == 2 "}
{"text": "import json    from taipy.gui.gui import Gui      def test_multiple_instance():      gui1 = Gui(\"<|gui1|>\")      gui2 = Gui(\"<|gui2|>\")      gui1.run(run_server=False)      gui2.run(run_server=False)      client1 = gui1._server.test_client()      client2 = gui2._server.test_client()      assert_multiple_instance(client1, 'value=\"gui1\"')      assert_multiple_instance(client2, 'value=\"gui2\"')      def assert_multiple_instance(client, expected_value):      response = client.get(\"/taipy-jsx/TaiPy_root_page\")      response_data = json.loads(response.get_data().decode(\"utf-8\", \"ignore\"))      assert response.status_code == 200      assert isinstance(response_data, dict)      assert \"jsx\" in response_data      assert expected_value in response_data[\"jsx\"] "}
{"text": "from taipy.gui.utils._variable_directory import _MODULE_NAME_MAP, _variable_decode, _variable_encode      def test_variable_encode_decode():      assert _variable_encode(\"x\", \"module\") == \"x_TPMDL_0\"      assert _MODULE_NAME_MAP[0] == \"module\"      assert _variable_decode(\"x_TPMDL_0\") == (\"x\", \"module\")      assert _variable_encode(\"x\", None) == \"x\"      assert _variable_decode(\"x\") == (\"x\", None)      assert _variable_encode(\"TpExPr_x\", \"module1\") == \"TpExPr_x_TPMDL_1\"      assert _MODULE_NAME_MAP[1] == \"module1\"      assert _variable_decode(\"TpExPr_x_TPMDL_1\") == (\"x\", \"module1\") "}
{"text": "import inspect  import warnings    from taipy.gui import Gui, Markdown, State, navigate      def test_navigate(gui: Gui, helpers):      def navigate_to(state: State):          navigate(state, \"test\")        with warnings.catch_warnings(record=True):          gui._set_frame(inspect.currentframe())          gui.add_page(\"test\", Markdown(\"#This is a page\"))          gui.run(run_server=False)          client = gui._server.test_client()          # WS client and emit          ws_client = gui._server._ws.test_client(gui._server.get_flask())          # Get the jsx once so that the page will be evaluated -> variable will be registered          sid = helpers.create_scope_and_get_sid(gui)          client.get(f\"/taipy-jsx/test/?client_id={sid}\")          ws_client.emit(\"message\", {\"client_id\": sid, \"type\": \"A\", \"name\": \"my_button\", \"payload\": \"navigate_to\"})          # assert for received message (message that would be sent to the front-end client)          assert ws_client.get_received()      def test_navigate_to_no_route(gui: Gui, helpers):      def navigate_to(state: State):          navigate(state, \"toto\")        with warnings.catch_warnings(record=True):          gui._set_frame(inspect.currentframe())          gui.add_page(\"test\", Markdown(\"#This is a page\"))          gui.run(run_server=False)          client = gui._server.test_client()          # WS client and emit          ws_client = gui._server._ws.test_client(gui._server.get_flask())          # Get the jsx once so that the page will be evaluated -> variable will be registered          sid = helpers.create_scope_and_get_sid(gui)          client.get(f\"/taipy-jsx/test/?client_id={sid}\")          ws_client.emit(\"message\", {\"client_id\": sid, \"type\": \"A\", \"name\": \"my_button\", \"payload\": \"navigate_to\"})          # assert for received message (message that would be sent to the front-end client)          assert not ws_client.get_received()      def test_on_navigate_to_inexistant(gui: Gui, helpers):      def on_navigate(state: State, page: str):          return \"test2\" if page == \"test\" else page        with warnings.catch_warnings(record=True) as records:          gui._set_frame(inspect.currentframe())          gui.add_page(\"test\", Markdown(\"#This is a page\"))          gui.run(run_server=False)          client = gui._server.test_client()          # Get the jsx once so that the page will be evaluated -> variable will be registered          sid = helpers.create_scope_and_get_sid(gui)          client.get(f\"/taipy-jsx/test?client_id={sid}\")          warns = helpers.get_taipy_warnings(records)          assert len(warns) == 1          text = warns[0].message.args[0] if isinstance(warns[0].message, Warning) else warns[0].message          assert text == 'Cannot navigate to \"test2\": unknown page.'      def test_on_navigate_to_existant(gui: Gui, helpers):      def on_navigate(state: State, page: str):          return \"test2\" if page == \"test1\" else page        with warnings.catch_warnings(record=True):          gui._set_frame(inspect.currentframe())          gui.add_page(\"test1\", Markdown(\"#This is a page test1\"))          gui.add_page(\"test2\", Markdown(\"#This is a page test2\"))          gui.run(run_server=False)          client = gui._server.test_client()          # Get the jsx once so that the page will be evaluated -> variable will be registered          sid = helpers.create_scope_and_get_sid(gui)          content = client.get(f\"/taipy-jsx/test1?client_id={sid}\")          assert content.status_code == 302 "}
{"text": "import inspect    import pandas as pd  # type: ignore    from taipy.gui import Gui      def test_expression_text_control_str(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"Hello World!\")      md_string = \"<|{x}|>\"      expected_list = [\"<Field\", 'dataType=\"str\"', 'defaultValue=\"Hello World!\"', \"value={tpec_TpExPr_x_TPMDL_0}\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_expression_text_control_int(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      md_string = \"<|{x}|>\"      expected_list = [\"<Field\", 'dataType=\"int\"', 'defaultValue=\"10\"', \"value={tpec_TpExPr_x_TPMDL_0}\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_expression_text_control_1(gui: Gui, test_client, helpers):      gui._set_frame(inspect.currentframe())      gui._bind_var_val(\"x\", 10)      gui._bind_var_val(\"y\", 20)      md_string = \"<|{x + y}|>\"      expected_list = [          \"<Field\",          'dataType=\"int\"',          'defaultValue=\"30\"',          \"value={tp_TpExPr_x_y_TPMDL_0_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_expression_text_control_2(gui: Gui, test_client, helpers):      gui._set_frame(inspect.currentframe())      gui._bind_var_val(\"x\", 10)      gui._bind_var_val(\"y\", 20)      md_string = \"<|x + y = {x + y}|>\"      expected_list = [          \"<Field\",          'dataType=\"str\"',          'defaultValue=\"x + y = 30\"',          \"value={tp_TpExPr_x_y_x_y_TPMDL_0_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_expression_text_control_3(gui: Gui, test_client, helpers):      gui._set_frame(inspect.currentframe())      gui._bind_var_val(\"x\", \"Mickey Mouse\")      gui._bind_var_val(\"y\", \"Donald Duck\")      md_string = \"<|Hello {x} and {y}|>\"      expected_list = [          \"<Field\",          'dataType=\"str\"',          'defaultValue=\"Hello Mickey Mouse and Donald Duck\"',          \"value={tp_TpExPr_Hello_x_and_y_TPMDL_0_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_expression_text_gt_operator(gui: Gui, test_client, helpers):      gui._set_frame(inspect.currentframe())      gui._bind_var_val(\"x\", 0)      md_string = \"<|{x > 0}|>\"      expected_list = [          \"<Field\",          'dataType=\"bool\"',          'defaultValue=\"false\"',          \"value={tp_TpExPr_x_0_TPMDL_0_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_expression_button_control(gui: Gui, test_client, helpers):      gui._bind_var_val(\"label\", \"A button label\")      md_string = \"<|button|label={label}|>\"      expected_list = [\"<Button\", 'defaultLabel=\"A button label\"', \"label={tpec_TpExPr_label_TPMDL_0}\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_expression_table_control(gui: Gui, test_client, helpers):      gui._set_frame(inspect.currentframe())      gui._bind_var_val(\"pd\", pd)      gui._bind_var_val(\"series_1\", pd.Series([\"a\", \"b\", \"c\"], name=\"Letters\"))      gui._bind_var_val(\"series_2\", pd.Series([1, 2, 3], name=\"Numbers\"))      md_string = \"<|{pd.concat([series_1, series_2], axis=1)}|table|columns=Letters;Numbers|>\"      expected_list = [          \"<Table\",          'defaultColumns=\"{&quot;Letters&quot;: &#x7B;&quot;index&quot;: 0, &quot;type&quot;: &quot;object&quot;, &quot;dfid&quot;: &quot;Letters&quot;&#x7D;, &quot;Numbers&quot;: &#x7B;&quot;index&quot;: 1, &quot;type&quot;: &quot;int&quot;, &quot;dfid&quot;: &quot;Numbers&quot;&#x7D;}\"',          'updateVarName=\"_TpD_tp_TpExPr_pd_concat_series_1_series_2_axis_1_TPMDL_0_0\"',          \"data={_TpD_tp_TpExPr_pd_concat_series_1_series_2_axis_1_TPMDL_0_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      assert isinstance(gui._get_data_scope().tp_TpExPr_pd_concat_series_1_series_2_axis_1_TPMDL_0_0, pd.DataFrame)      def test_lambda_expression_selector(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"lov\",          [              {\"id\": \"1\", \"name\": \"scenario 1\"},              {\"id\": \"3\", \"name\": \"scenario 3\"},              {\"id\": \"2\", \"name\": \"scenario 2\"},          ],      )      gui._bind_var_val(\"sel\", {\"id\": \"1\", \"name\": \"scenario 1\"})      md_string = \"<|{sel}|selector|lov={lov}|type=test|adapter={lambda elt: (elt['id'], elt['name'])}|>\"      expected_list = [          \"<Selector\",          'defaultLov=\"[[&quot;1&quot;, &quot;scenario 1&quot;], [&quot;3&quot;, &quot;scenario 3&quot;], [&quot;2&quot;, &quot;scenario 2&quot;]]\"',          'defaultValue=\"[&quot;1&quot;]\"',          'updateVars=\"lov=_TpL_tpec_TpExPr_lov_TPMDL_0\"',          \"lov={_TpL_tpec_TpExPr_lov_TPMDL_0}\",          'updateVarName=\"_TpLv_tpec_TpExPr_sel_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_sel_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list) "}
{"text": "import numpy as np  import pandas as pd    from taipy.gui.data.decimator.lttb import LTTB  from taipy.gui.data.decimator.minmax import MinMaxDecimator  from taipy.gui.data.decimator.rdp import RDP  from taipy.gui.data.decimator.scatter_decimator import ScatterDecimator  from taipy.gui.data.utils import _df_data_filter      def test_data_filter_1(csvdata):      df, _ = _df_data_filter(csvdata[:1500], None, \"Daily hospital occupancy\", \"\", MinMaxDecimator(100), {}, False)      assert df.shape[0] == 100      def test_data_filter_2(csvdata):      df, _ = _df_data_filter(csvdata[:1500], None, \"Daily hospital occupancy\", \"\", LTTB(100), {}, False)      assert df.shape[0] == 100      def test_data_filter_3(csvdata):      df, _ = _df_data_filter(csvdata[:1500], None, \"Daily hospital occupancy\", \"\", RDP(n_out=100), {}, False)      assert df.shape[0] == 100      def test_data_filter_4(csvdata):      df, _ = _df_data_filter(csvdata[:1500], None, \"Daily hospital occupancy\", \"\", RDP(epsilon=100), {}, False)      assert df.shape[0] == 18      def test_data_filter_5(csvdata):      df, _ = _df_data_filter(          csvdata[:1500], None, \"Daily hospital occupancy\", \"\", ScatterDecimator(), {\"width\": 200, \"height\": 100}, False      )      assert df.shape[0] == 1150 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import inspect    import pytest    from taipy.gui import Gui, Markdown    from .state_asset.page1 import get_a, md_page1, set_a      def test_state(gui: Gui):      a = 10  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.add_page(\"page1\", md_page1)      gui.run(run_server=False, single_client=True)      state = gui._Gui__state      with gui.get_flask_app().app_context():          assert state.a == 10          assert state[\"page1\"].a == 20          assert state[\"tests.taipy.gui.gui_specific.state_asset.page1\"].a == 20          assert state._gui == gui          with pytest.raises(Exception) as e:              state.b          assert e.value.args[0] == \"Variable 'b' is not defined.\"            with pytest.raises(Exception) as e:              state.b = 10          assert e.value.args[0] == \"Variable 'b' is not accessible.\"            with pytest.raises(Exception) as e:              state._taipy_p1          assert e.value.args[0] == \"Variable '_taipy_p1' is protected and is not accessible.\"            with pytest.raises(Exception) as e:              state._taipy_p1 = 10          assert e.value.args[0] == \"Variable '_taipy_p1' is not accessible.\"            assert state._get_placeholder(\"_taipy_p1\") is None            state._set_placeholder(\"_taipy_p1\", 10)            assert state._get_placeholder(\"_taipy_p1\") == 10            assert state._get_placeholder_attrs() == (              \"_taipy_p1\",              \"_current_context\",          )            assert get_a(state) == 20            set_a(state, 30)            assert get_a(state) == 30 "}
{"text": "import pytest    from taipy.gui import Gui  from taipy.gui.utils._locals_context import _LocalsContext      def test_locals_context(gui: Gui):      lc = _LocalsContext()      gui.run(run_server=False)      with gui.get_flask_app().app_context():          with pytest.raises(KeyError):              lc.get_default()          current_locals = locals()          lc.set_default(current_locals)          assert lc.get_default() == current_locals          temp_locals = {\"__main__\": \"test\"}          lc.add(\"test\", temp_locals)          assert lc.get_context() is None          assert lc.get_locals() == current_locals          with lc.set_locals_context(\"test\"):              assert lc.get_context() == \"test\"              assert lc.get_locals() == temp_locals          assert lc.get_context() is None          assert lc.get_locals() == current_locals          assert lc.is_default() is True          assert \"__main__\" in lc.get_all_keys() "}
{"text": "import inspect    from taipy.gui.utils.get_module_name import _get_module_name_from_frame, _get_module_name_from_imported_var    x = 10      def test_get_module_name():      assert \"tests.taipy.gui.gui_specific.test_get_module_name\" == _get_module_name_from_frame(inspect.currentframe())      def test_get_module_name_imported_var():      assert \"tests.taipy.gui.gui_specific.test_get_module_name\" == _get_module_name_from_imported_var(          \"x\", 10, \"test_get_module_name\"      )      assert \"test_get_module_name\" == _get_module_name_from_imported_var(\"x\", 11, \"test_get_module_name\") "}
{"text": "import inspect  import os  from pathlib import Path    from taipy.gui import Gui      def test_folder_pages_binding(gui: Gui):      folder_path = f\"{Path(Path(__file__).parent.resolve())}{os.path.sep}sample_assets\"      gui._set_frame(inspect.currentframe())      gui.add_pages(folder_path)      gui.run(run_server=False)      assert len(gui._config.routes) == 3  # 2 files -> 2 routes + 1 default route      assert len(gui._config.pages) == 3  # 2 files -> 2 pages + 1 default page "}
{"text": "import inspect  import json  import warnings    from taipy.gui import Gui      def test_render_route(gui: Gui):      gui._set_frame(inspect.currentframe())      gui.add_page(\"page1\", \"# first page\")      gui.add_page(\"page2\", \"# second page\")      gui.run(run_server=False)      with warnings.catch_warnings(record=True):          client = gui._server.test_client()          response = client.get(\"/taipy-init\")          response_data = json.loads(response.get_data().decode(\"utf-8\", \"ignore\"))          assert response.status_code == 200          assert isinstance(response_data, dict)          assert isinstance(response_data[\"locations\"], dict)          assert \"/page1\" in response_data[\"locations\"]          assert \"/page2\" in response_data[\"locations\"]          assert \"/\" in response_data[\"locations\"]          assert response_data[\"locations\"] == {\"/\": \"/TaiPy_root_page\", \"/page1\": \"/page1\", \"/page2\": \"/page2\"} "}
{"text": "import json    import pandas as pd  import pytest    from taipy.gui import Gui  from taipy.gui.utils import _TaipyContent      def test__get_real_var_name(gui: Gui):      res = gui._get_real_var_name(\"\")      assert isinstance(res, tuple)      assert res[0] == \"\"      assert res[1] == \"\"        gui.run(run_server=False)      with gui.get_flask_app().app_context():          with pytest.raises(NameError):              res = gui._get_real_var_name(f\"{_TaipyContent.get_hash()}_var\")      def test__get_user_instance(gui: Gui):      gui.run(run_server=False)      with gui.get_flask_app().app_context():          with pytest.warns(UserWarning):              gui._get_user_instance(\"\", type(None))      def test__call_broadcast_callback(gui: Gui):      gui.run(run_server=False)      with gui.get_flask_app().app_context():          res = gui._call_broadcast_callback(lambda s, t: t, [\"Hello World\"], \"mine\")          assert res == \"Hello World\"        with gui.get_flask_app().app_context():          with pytest.warns(UserWarning):              res = gui._call_broadcast_callback(print, [\"Hello World\"], \"mine\")              assert res is None      def test__refresh_expr(gui: Gui):      gui.run(run_server=False)      with gui.get_flask_app().app_context():          res = gui._refresh_expr(\"var\", None)          assert res is None      def test__tbl_cols(gui: Gui):      data = pd.DataFrame({\"col1\": [0, 1, 2], \"col2\": [True, True, False]})      gui.run(run_server=False)      with gui.get_flask_app().app_context():          res = gui._tbl_cols(True, None, json.dumps({}), json.dumps({\"data\": \"data\"}), data=data)          d = json.loads(res)          assert isinstance(d, dict)          assert d[\"col1\"][\"type\"] == \"int\"            res = gui._tbl_cols(False, None, \"\", \"\")          assert repr(res) == \"Taipy: Do not update\"      def test__chart_conf(gui: Gui):      data = pd.DataFrame({\"col1\": [0, 1, 2], \"col2\": [True, True, False]})      gui.run(run_server=False)      with gui.get_flask_app().app_context():          res = gui._chart_conf(True, None, json.dumps({}), json.dumps({\"data\": \"data\"}), data=data)          d = json.loads(res)          assert isinstance(d, dict)          assert d[\"columns\"][\"col1\"][\"type\"] == \"int\"            res = gui._chart_conf(False, None, \"\", \"\")          assert repr(res) == \"Taipy: Do not update\"            with pytest.warns(UserWarning):              res = gui._chart_conf(True, None, \"\", \"\")              assert repr(res) == \"Taipy: Do not update\"      def test__get_valid_adapter_result(gui: Gui):      gui.run(run_server=False)      with gui.get_flask_app().app_context():          res = gui._get_valid_adapter_result((\"id\", \"label\"))          assert isinstance(res, tuple)          assert res[0] == \"id\" "}
{"text": "import json  import warnings  from types import SimpleNamespace    from taipy.gui import Gui, Markdown      def test_partial(gui: Gui):      with warnings.catch_warnings(record=True):          gui.add_partial(Markdown(\"#This is a partial\"))          gui.run(run_server=False)          client = gui._server.test_client()          response = client.get(f\"/taipy-jsx/{gui._config.partial_routes[0]}\")          response_data = json.loads(response.get_data().decode(\"utf-8\", \"ignore\"))          assert response.status_code == 200          assert \"jsx\" in response_data and \"This is a partial\" in response_data[\"jsx\"]      def test_partial_update(gui: Gui):      with warnings.catch_warnings(record=True):          partial = gui.add_partial(Markdown(\"#This is a partial\"))          gui.run(run_server=False, single_client=True)          client = gui._server.test_client()          response = client.get(f\"/taipy-jsx/{gui._config.partial_routes[0]}\")          response_data = json.loads(response.get_data().decode(\"utf-8\", \"ignore\"))          assert response.status_code == 200          assert \"jsx\" in response_data and \"This is a partial\" in response_data[\"jsx\"]          # update partial          fake_state = SimpleNamespace()          fake_state._gui = gui          partial.update_content(fake_state, \"#partial updated\")  # type: ignore          response = client.get(f\"/taipy-jsx/{gui._config.partial_routes[0]}\")          response_data = json.loads(response.get_data().decode(\"utf-8\", \"ignore\"))          assert response.status_code == 200          assert \"jsx\" in response_data and \"partial updated\" in response_data[\"jsx\"] "}
{"text": "from taipy.gui import Gui, Markdown      def test_variable_binding(helpers):      \"\"\"      Tests the binding of a few variables and a function      \"\"\"        def another_function(gui):          pass        x = 10      y = 20      z = \"button label\"      gui = Gui()      gui.add_page(\"test\", Markdown(\"<|{x}|> | <|{y}|> | <|{z}|button|on_action=another_function|>\"))      gui.run(run_server=False, single_client=True)      client = gui._server.test_client()      jsx = client.get(\"/taipy-jsx/test\").json[\"jsx\"]      for expected in [\"<Button\", 'defaultLabel=\"button label\"', \"label={tpec_TpExPr_z_TPMDL_0}\"]:          assert expected in jsx      assert gui._bindings().x == x      assert gui._bindings().y == y      assert gui._bindings().z == z      with gui.get_flask_app().app_context():          assert callable(gui._get_user_function(\"another_function\"))      helpers.test_cleanup()      def test_properties_binding(helpers):      gui = Gui()      modifier = \"nice \"  # noqa: F841      button_properties = {\"label\": \"A {modifier}button\"}  # noqa: F841      gui.add_page(\"test\", Markdown(\"<|button|properties=button_properties|>\"))      gui.run(run_server=False)      client = gui._server.test_client()      jsx = client.get(\"/taipy-jsx/test\").json[\"jsx\"]      for expected in [\"<Button\", 'defaultLabel=\"A nice button\"']:          assert expected in jsx      helpers.test_cleanup()      def test_dict_binding(helpers):      \"\"\"      Tests the binding of a dictionary property      \"\"\"      d = {\"k\": \"test\"}  # noqa: F841      gui = Gui(\"<|{d.k}|>\")      gui.run(run_server=False)      client = gui._server.test_client()      jsx = client.get(\"/taipy-jsx/TaiPy_root_page\").json[\"jsx\"]      for expected in [\"<Field\", 'defaultValue=\"test\"']:          assert expected in jsx      helpers.test_cleanup() "}
{"text": "from taipy.gui import Markdown    a = 20      def get_a(state):      return state.a      def set_a(state, val):      state.a = val      md_page1 = Markdown(      \"\"\"  <|{a}|>  \"\"\"  ) "}
{"text": "import inspect    import pytest    from taipy.gui import Gui  from taipy.gui.extension import Element, ElementLibrary      class MyLibrary(ElementLibrary):      def get_name(self) -> str:          return \"taipy_extension_example\"        def get_elements(self):          return dict()      def test_extension_no_config(gui: Gui, helpers):      gui.run(run_server=False, single_client=True)      flask_client = gui._server.test_client()      with pytest.warns(UserWarning):          ret = flask_client.get(\"/taipy-extension/toto/titi\")          assert ret.status_code == 404      def test_extension_config_wrong_path(gui: Gui, helpers):      Gui.add_library(MyLibrary())      gui.run(run_server=False, single_client=True)      flask_client = gui._server.test_client()      with pytest.warns(UserWarning):          ret = flask_client.get(\"/taipy-extension/taipy_extension_example/titi\")          assert ret.status_code == 404 "}
{"text": "import inspect    import pytest  from flask import g    from taipy.gui import Gui      def test_get_status(gui: Gui):      gui.run(run_server=False)      flask_client = gui._server.test_client()      ret = flask_client.get(\"/taipy.status.json\")      assert ret.status_code == 200, f\"status_code => {ret.status_code} != 200\"      assert ret.mimetype == \"application/json\", f\"mimetype => {ret.mimetype} != application/json\"      assert ret.json, \"json is not defined\"      assert \"gui\" in ret.json, \"json has no key gui\"      gui = ret.json.get(\"gui\")      assert isinstance(gui, dict), \"json.gui is not a dict\"      assert \"user_status\" in gui, \"json.gui has no key user_status\"      assert gui.get(\"user_status\") == \"\", \"json.gui.user_status is not empty\"      def test_get_extended_status(gui: Gui):      gui.run(run_server=False, extended_status=True)      flask_client = gui._server.test_client()      ret = flask_client.get(\"/taipy.status.json\")      assert ret.status_code == 200, f\"status_code => {ret.status_code} != 200\"      assert ret.mimetype == \"application/json\", f\"mimetype => {ret.mimetype} != application/json\"      assert ret.json, \"json is not defined\"      gui = ret.json.get(\"gui\")      assert \"backend_version\" in gui, \"json.gui has no key backend_version\"      assert \"flask_version\" in gui, \"json.gui has no key flask_version\"      assert \"frontend_version\" in gui, \"json.gui has no key frontend_version\"      assert \"host\" in gui, \"json.gui has no key host\"      assert \"python_version\" in gui, \"json.gui has no key python_version\"      assert \"user_status\" in gui, \"json.gui has no key user_status\"      assert gui.get(\"user_status\") == \"\", \"json.gui.user_status is not empty\"      def test_get_status_with_user_status(gui: Gui):      user_status = \"user_status\"        def on_status(state):          return user_status        gui._set_frame(inspect.currentframe())        gui.run(run_server=False)      flask_client = gui._server.test_client()      ret = flask_client.get(\"/taipy.status.json\")      assert ret.status_code == 200, f\"status_code => {ret.status_code} != 200\"      assert ret.json, \"json is not defined\"      gui = ret.json.get(\"gui\")      assert \"user_status\" in gui, \"json.gui has no key user_status\"      assert gui.get(\"user_status\") == user_status, f'json.gui.user_status => {gui.get(\"user_status\")} != {user_status}' "}
{"text": "import inspect  import io  import pathlib  import tempfile    import pytest    from taipy.gui import Gui  from taipy.gui.data.data_scope import _DataScopes  from taipy.gui.utils import _get_non_existent_file_path      def test_file_upload_no_varname(gui: Gui, helpers):      gui.run(run_server=False)      flask_client = gui._server.test_client()      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      with pytest.warns(UserWarning):          ret = flask_client.post(f\"/taipy-uploads?client_id={sid}\")          assert ret.status_code == 400      def test_file_upload_no_blob(gui: Gui, helpers):      gui.run(run_server=False)      flask_client = gui._server.test_client()      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      with pytest.warns(UserWarning):          ret = flask_client.post(f\"/taipy-uploads?client_id={sid}\", data={\"var_name\": \"varname\"})          assert ret.status_code == 400      def test_file_upload_no_filename(gui: Gui, helpers):      gui.run(run_server=False)      flask_client = gui._server.test_client()      file = (io.BytesIO(b\"abcdef\"), \"\")      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      with pytest.warns(UserWarning):          ret = flask_client.post(f\"/taipy-uploads?client_id={sid}\", data={\"var_name\": \"varname\", \"blob\": file})          assert ret.status_code == 400      def test_file_upload_simple(gui: Gui, helpers):      gui.run(run_server=False)      flask_client = gui._server.test_client()      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      file_name = \"test.jpg\"      file = (io.BytesIO(b\"abcdef\"), file_name)      upload_path = pathlib.Path(gui._get_config(\"upload_folder\", tempfile.gettempdir()))      file_name = _get_non_existent_file_path(upload_path, file_name).name      ret = flask_client.post(          f\"/taipy-uploads?client_id={sid}\",          data={\"var_name\": \"varname\", \"blob\": file},          content_type=\"multipart/form-data\",      )      assert ret.status_code == 200      created_file = upload_path / file_name      assert created_file.exists()      def test_file_upload_multi_part(gui: Gui, helpers):      gui.run(run_server=False)      flask_client = gui._server.test_client()      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      file_name = \"test2.jpg\"      file0 = (io.BytesIO(b\"abcdef\"), file_name)      file1 = (io.BytesIO(b\"abcdef\"), file_name)      upload_path = pathlib.Path(gui._get_config(\"upload_folder\", tempfile.gettempdir()))      file_name = _get_non_existent_file_path(upload_path, file_name).name      ret = flask_client.post(          f\"/taipy-uploads?client_id={sid}\",          data={\"var_name\": \"varname\", \"blob\": file0, \"total\": \"2\", \"part\": \"0\"},          content_type=\"multipart/form-data\",      )      assert ret.status_code == 200      file0_path = upload_path / f\"{file_name}.part.0\"      assert file0_path.exists()      ret = flask_client.post(          f\"/taipy-uploads?client_id={sid}\",          data={\"var_name\": \"varname\", \"blob\": file1, \"total\": \"2\", \"part\": \"1\"},          content_type=\"multipart/form-data\",      )      assert ret.status_code == 200      file1_path = upload_path / f\"{file_name}.part.1\"      assert file1_path.exists()      file_path = upload_path / file_name      assert file_path.exists()      def test_file_upload_multiple(gui: Gui, helpers):      var_name = \"varname\"      gui._set_frame(inspect.currentframe())      gui.run(run_server=False, single_client=True)      flask_client = gui._server.test_client()      with gui.get_flask_app().app_context():          gui._bind_var_val(var_name, None)      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = _DataScopes._GLOBAL_ID      file = (io.BytesIO(b\"abcdef\"), \"test.jpg\")      ret = flask_client.post(          f\"/taipy-uploads?client_id={sid}\", data={\"var_name\": var_name, \"blob\": file}, content_type=\"multipart/form-data\"      )      assert ret.status_code == 200      created_file = pathlib.Path(gui._get_config(\"upload_folder\", tempfile.gettempdir())) / \"test.jpg\"      assert created_file.exists()      file2 = (io.BytesIO(b\"abcdef\"), \"test2.jpg\")      ret = flask_client.post(          f\"/taipy-uploads?client_id={sid}\",          data={\"var_name\": var_name, \"blob\": file2, \"multiple\": \"True\"},          content_type=\"multipart/form-data\",      )      assert ret.status_code == 200      created_file = pathlib.Path(gui._get_config(\"upload_folder\", tempfile.gettempdir())) / \"test2.jpg\"      assert created_file.exists()      value = getattr(gui._bindings()._get_all_scopes()[sid], var_name)      assert len(value) == 2 "}
{"text": "import pathlib    import pytest    from taipy.gui import Gui      def test_image_path_not_found(gui: Gui, helpers):      gui.run(run_server=False)      flask_client = gui._server.test_client()      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      ret = flask_client.get(f\"/taipy-images/images/img.png?client_id={sid}\")      assert ret.status_code == 404      def test_image_path_found(gui: Gui, helpers):      url = gui._get_content(          \"img\", str((pathlib.Path(__file__).parent.parent.parent / \"resources\" / \"fred.png\").resolve()), True      )      gui.run(run_server=False)      flask_client = gui._server.test_client()      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      ret = flask_client.get(f\"{url}?client_id={sid}\")      assert ret.status_code == 200      def test_image_data_too_big(gui: Gui, helpers):      with open((pathlib.Path(__file__).parent.parent.parent / \"resources\" / \"taipan.jpg\"), \"rb\") as big_file:          url = gui._get_content(\"img\", big_file.read(), True)          assert not url.startswith(\"data:\") "}
{"text": "import inspect    import pytest    from taipy.gui import Gui      def test_user_content_without_callback(gui: Gui, helpers):      gui.run(run_server=False, single_client=True)      flask_client = gui._server.test_client()      with pytest.warns(UserWarning):          ret = flask_client.get(gui._get_user_content_url(\"path\"))          assert ret.status_code == 404      def test_user_content_with_wrong_callback(gui: Gui, helpers):      def on_user_content_cb(state, path, args):          return None        on_user_content = on_user_content_cb      gui._set_frame(inspect.currentframe())      gui.run(run_server=False, single_client=True)      flask_client = gui._server.test_client()      with pytest.warns(UserWarning):          ret = flask_client.get(gui._get_user_content_url(\"path\", {\"a\": \"b\"}))          assert ret.status_code == 404      def test_user_content_with_callback(gui: Gui, helpers):      def on_user_content_cb(state, path, args):          return \"\"        on_user_content = on_user_content_cb      gui._set_frame(inspect.currentframe())      gui.run(run_server=False, single_client=True)      flask_client = gui._server.test_client()      ret = flask_client.get(gui._get_user_content_url(\"path\"))      assert ret.status_code == 200 "}
{"text": "import inspect    from taipy.gui import Gui, Markdown  from taipy.gui.data.data_scope import _DataScopes      def test_sending_messages_in_group(gui: Gui, helpers):      name = \"World!\"  # noqa: F841      btn_id = \"button1\"  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|Hello {name}|button|id={btn_id}|>\"))      gui.run(run_server=False, single_client=True)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      cid = _DataScopes._GLOBAL_ID      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={cid}\")      assert gui._bindings()._get_all_scopes()[cid].name == \"World!\"  # type: ignore      assert gui._bindings()._get_all_scopes()[cid].btn_id == \"button1\"  # type: ignore        with gui.get_flask_app().test_request_context(f\"/taipy-jsx/test/?client_id={cid}\", data={\"client_id\": cid}):          with gui as aGui:              aGui._Gui__state.name = \"Monde!\"              aGui._Gui__state.btn_id = \"button2\"        assert gui._bindings()._get_all_scopes()[cid].name == \"Monde!\"      assert gui._bindings()._get_all_scopes()[cid].btn_id == \"button2\"  # type: ignore        received_messages = ws_client.get_received()      helpers.assert_outward_ws_multiple_message(received_messages[0], \"MS\", 2) "}
{"text": "import inspect  import logging  import pathlib    import pytest    from taipy.gui import Gui, download      def test_download_file(gui: Gui, helpers):      def do_something(state, id):          download(state, (pathlib.Path(__file__).parent.parent.parent / \"resources\" / \"taipan.jpg\"))        # Bind a page so that the function will be called      # gui.add_page(      #     \"test\", Markdown(\"<|Do something!|button|on_action=do_something|id=my_button|>\")      # )      # set gui frame      gui._set_frame(inspect.currentframe())        gui.run(run_server=False)      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      ws_client.emit(\"message\", {\"client_id\": sid, \"type\": \"A\", \"name\": \"my_button\", \"payload\": \"do_something\"})      # assert for received message (message that would be sent to the front-end client)      received_messages = ws_client.get_received()      assert len(received_messages) == 1      assert isinstance(received_messages[0], dict)      assert \"name\" in received_messages[0] and received_messages[0][\"name\"] == \"message\"      assert \"args\" in received_messages[0]      args = received_messages[0][\"args\"]      assert \"type\" in args and args[\"type\"] == \"DF\"      assert \"content\" in args and args[\"content\"] == \"/taipy-content/taipyStatic0/taipan.jpg\"      logging.getLogger().debug(args[\"content\"]) "}
{"text": "import inspect    from taipy.gui import Gui, Markdown      def ws_u_assert_template(gui: Gui, helpers, value_before_update, value_after_update, payload):      # Bind test variable      var = value_before_update  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        # Bind a page so that the variable will be evaluated as expression      gui.add_page(\"test\", Markdown(\"<|{var}|>\"))      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      flask_client.get(f\"/taipy-jsx/test?client_id={sid}\")      assert gui._bindings()._get_all_scopes()[sid].var == value_before_update      ws_client.emit(\"message\", {\"client_id\": sid, \"type\": \"U\", \"name\": \"tpec_TpExPr_var_TPMDL_0\", \"payload\": payload})      assert gui._bindings()._get_all_scopes()[sid].var == value_after_update      # assert for received message (message that would be sent to the front-end client)      received_message = ws_client.get_received()      assert len(received_message)      helpers.assert_outward_ws_message(received_message[0], \"MU\", \"tpec_TpExPr_var_TPMDL_0\", value_after_update)      def test_ws_u_string(gui: Gui, helpers):      value_before_update = \"a random string\"      value_after_update = \"a random string is added\"      payload = {\"value\": value_after_update}        # set gui frame      gui._set_frame(inspect.currentframe())        ws_u_assert_template(gui, helpers, value_before_update, value_after_update, payload)      def test_ws_u_number(gui: Gui, helpers):      value_before_update = 10      value_after_update = \"11\"      payload = {\"value\": value_after_update}        # set gui frame      gui._set_frame(inspect.currentframe())        ws_u_assert_template(gui, helpers, value_before_update, value_after_update, payload) "}
{"text": "import inspect    from taipy.gui import Gui, Markdown      def test_du_table_data_fetched(gui: Gui, helpers, csvdata):      # Bind test variables      csvdata = csvdata        # set gui frame      gui._set_frame(inspect.currentframe())      Gui._set_timezone(\"UTC\")        # Bind a page so that the variable will be evaluated as expression      gui.add_page(          \"test\",          Markdown(              \"<|{csvdata}|table|page_size=10|page_size_options=10;30;100|columns=Day;Entity;Code;Daily hospital occupancy|date_format=eee dd MMM yyyy|>\"          ),      )      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      sid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={sid}\")      ws_client.emit(          \"message\",          {              \"client_id\": sid,              \"type\": \"DU\",              \"name\": \"_TpD_tpec_TpExPr_csvdata_TPMDL_0\",              \"payload\": {                  \"columns\": [\"Day\", \"Entity\", \"Code\", \"Daily hospital occupancy\"],                  \"pagekey\": \"0-100--asc\",                  \"start\": 0,                  \"end\": 9,                  \"orderby\": \"\",                  \"sort\": \"asc\",              },          },      )      # assert for received message (message that would be sent to the front-end client)      received_messages = ws_client.get_received()      assert received_messages      helpers.assert_outward_ws_message(          received_messages[0],          \"MU\",          \"_TpD_tpec_TpExPr_csvdata_TPMDL_0\",          {              \"data\": [                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-01T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 856,                      \"Entity\": \"Austria\",                      \"_tp_index\": 0,                  },                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-02T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 823,                      \"Entity\": \"Austria\",                      \"_tp_index\": 1,                  },                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-03T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 829,                      \"Entity\": \"Austria\",                      \"_tp_index\": 2,                  },                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-04T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 826,                      \"Entity\": \"Austria\",                      \"_tp_index\": 3,                  },                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-05T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 712,                      \"Entity\": \"Austria\",                      \"_tp_index\": 4,                  },                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-06T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 824,                      \"Entity\": \"Austria\",                      \"_tp_index\": 5,                  },                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-07T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 857,                      \"Entity\": \"Austria\",                      \"_tp_index\": 6,                  },                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-08T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 829,                      \"Entity\": \"Austria\",                      \"_tp_index\": 7,                  },                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-09T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 820,                      \"Entity\": \"Austria\",                      \"_tp_index\": 8,                  },                  {                      \"Code\": \"AUT\",                      \"Day_str\": \"2020-04-10T00:00:00.000000Z\",                      \"Daily hospital occupancy\": 771,                      \"Entity\": \"Austria\",                      \"_tp_index\": 9,                  },              ],              \"rowcount\": 14477,              \"start\": 0,              \"format\": \"JSON\",          },      ) "}
{"text": "import inspect    import pytest    from taipy.gui import Gui, Markdown      def test_default_on_change(gui: Gui, helpers):      st = {\"d\": False}        def on_change(state, var, value):          st[\"d\"] = True        x = 10  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|{x}|input|>\"))      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      flask_client.get(f\"/taipy-jsx/test?client_id={sid}\")      # fake var update      ws_client.emit(\"message\", {\"client_id\": sid, \"type\": \"U\", \"name\": \"x\", \"payload\": {\"value\": \"20\"}})      assert ws_client.get_received()      assert st[\"d\"] is True      def test_specific_on_change(gui: Gui, helpers):      st = {\"d\": False, \"s\": False}        def on_change(state, var, value):          st[\"d\"] = True        def on_input_change(state, var, value):          st[\"s\"] = True        x = 10  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|{x}|input|on_change=on_input_change|>\"))      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      flask_client.get(f\"/taipy-jsx/test?client_id={sid}\")      # fake var update      ws_client.emit(          \"message\",          {\"client_id\": sid, \"type\": \"U\", \"name\": \"x\", \"payload\": {\"value\": \"20\", \"on_change\": \"on_input_change\"}},      )      assert ws_client.get_received()      assert st[\"s\"] is True      assert st[\"d\"] is False "}
{"text": "import inspect    import pytest    from taipy.gui import Gui, Markdown      def test_ru_selector(gui: Gui, helpers, csvdata):      # Bind test variables      selected_val = [\"value1\", \"value2\"]  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        # Bind a page so that the variable will be evaluated as expression      gui.add_page(          \"test\",          Markdown(\"<|{selected_val}|selector|multiple|>\"),      )      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      sid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={sid}\")      ws_client.emit(\"message\", {\"client_id\": sid, \"type\": \"RU\", \"name\": \"\", \"payload\": {\"names\": [\"selected_val\"]}})      # assert for received message (message that would be sent to the front-end client)      received_messages = ws_client.get_received()      assert len(received_messages)      helpers.assert_outward_ws_message(received_messages[0], \"MU\", \"selected_val\", [\"value1\", \"value2\"]) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import inspect    import pytest    from taipy.gui import Gui, Markdown      def test_broadcast(gui: Gui, helpers):      # Bind test variables      selected_val = [\"value1\", \"value2\"]  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        # Bind a page so that the variable will be evaluated as expression      gui.add_page(          \"test\",          Markdown(\"<|{selected_val}|selector|multiple|>\"),      )      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      sid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={sid}\")      gui._broadcast(\"broadcast_name\", \"broadcast_value\")      received_messages = ws_client.get_received()      assert len(received_messages)      helpers.assert_outward_simple_ws_message(received_messages[0], \"U\", \"_bc_broadcast_name\", \"broadcast_value\") "}
{"text": "import inspect  import time    from taipy.gui import Gui, Markdown      def test_a_button_pressed(gui: Gui, helpers):      def do_something(state, id):          state.x = state.x + 10          state.text = \"a random text\"        x = 10  # noqa: F841      text = \"hi\"  # noqa: F841      # set gui frame      gui._set_frame(inspect.currentframe())      # Bind a page so that the variable will be evaluated as expression      gui.add_page(          \"test\", Markdown(\"<|Do something!|button|on_action=do_something|id=my_button|> | <|{x}|> | <|{text}|>\")      )      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      # Get the jsx once so that the page will be evaluated -> variable will be registered      sid = helpers.create_scope_and_get_sid(gui)      flask_client.get(f\"/taipy-jsx/test?client_id={sid}\")      assert gui._bindings()._get_all_scopes()[sid].x == 10  # type: ignore      assert gui._bindings()._get_all_scopes()[sid].text == \"hi\"  # type: ignore      ws_client.emit(\"message\", {\"client_id\": sid, \"type\": \"A\", \"name\": \"my_button\", \"payload\": \"do_something\"})      assert gui._bindings()._get_all_scopes()[sid].text == \"a random text\"      assert gui._bindings()._get_all_scopes()[sid].x == 20  # type: ignore      # assert for received message (message that would be sent to the front-end client)      received_messages = ws_client.get_received()      helpers.assert_outward_ws_message(received_messages[0], \"MU\", \"x\", 20)      helpers.assert_outward_ws_message(received_messages[1], \"MU\", \"text\", \"a random text\") "}
{"text": "import inspect  import warnings    from flask import g    from taipy.gui import Gui  from taipy.gui.utils.types import _TaipyNumber      def test_unbind_variable_in_expression(gui: Gui, helpers):      gui.run(run_server=False, single_client=True)      with warnings.catch_warnings(record=True) as records:          with gui.get_flask_app().app_context():              gui._evaluate_expr(\"{x}\")              warns = helpers.get_taipy_warnings(records)              assert len(warns) == 3              assert \"Variable 'x' is not available in\" in str(warns[0].message)              assert \"Variable 'x' is not defined\" in str(warns[1].message)              assert \"Cannot evaluate expression 'x'\" in str(warns[2].message)              assert \"name 'x' is not defined\" in str(warns[2].message)      def test_evaluate_same_expression_multiple_times(gui: Gui):      x = 10  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.run(run_server=False, single_client=True)      with gui.get_flask_app().app_context():          s1 = gui._evaluate_expr(\"x + 10 = {x + 10}\")          s2 = gui._evaluate_expr(\"x + 10 = {x + 10}\")          assert s1 == s2      def test_evaluate_expressions_same_variable(gui: Gui):      x = 10  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.run(run_server=False, single_client=True)      with gui.get_flask_app().app_context():          s1 = gui._evaluate_expr(\"x + 10 = {x + 10}\")          s2 = gui._evaluate_expr(\"x = {x}\")          assert \"tp_TpExPr_x\" in s1 and \"tp_TpExPr_x\" in s2      def test_evaluate_holder(gui: Gui):      x = 10  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.run(run_server=False, single_client=True)      with warnings.catch_warnings(record=True):          with gui.get_flask_app().app_context():              gui._evaluate_expr(\"{x + 10}\")              hash = gui._evaluate_bind_holder(_TaipyNumber, \"TpExPr_x + 10_TPMDL_0\")              assert \"_TpN_tp_TpExPr_x_10_TPMDL_0_0\" in hash              lst = gui._evaluate_holders(\"TpExPr_x + 10_TPMDL_0\")              assert len(lst) == 1              assert \"_TpN_tp_TpExPr_x_10_TPMDL_0_0\" in lst[0]              # test re-evaluate holders              gui._bindings().x = 20              gui._re_evaluate_expr(lst[0])      def test_evaluate_not_expression_type(gui: Gui):      gui.run(run_server=False)      with gui.get_flask_app().app_context():          assert \"x + 10\" == gui._evaluate_expr(\"x + 10\")      def test_evaluate_expression_2_clients(gui: Gui):      x = 10  # noqa: F841      y = 20  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.run(run_server=False)      with gui.get_flask_app().app_context():          gui._bindings()._get_or_create_scope(\"A\")          gui._bindings()._get_or_create_scope(\"B\")          g.client_id = \"A\"          gui._evaluate_expr(\"x + y = {x + y}\")          g.client_id = \"B\"          gui._evaluate_expr(\"x\")          gui._re_evaluate_expr(\"x\") "}
{"text": "import inspect    import pytest    from taipy.gui.gui import Gui  from taipy.gui.utils import _MapDict      def test_map_dict():      d = {\"a\": 1, \"b\": 2, \"c\": 3}      md = _MapDict(d)      md_copy = _MapDict(d).copy()      assert len(md) == 3      assert md.__getitem__(\"a\") == d[\"a\"]      md.__setitem__(\"a\", 4)      assert md.__getitem__(\"a\") == 4      assert d[\"a\"] == 4      v1 = d[\"b\"]      v2 = md.pop(\"b\")      assert v1 == v2      assert \"b\" not in d.keys()      assert \"c\" in md      assert len(md) == 2      v1 = d[\"c\"]      v2 = md.popitem()      assert v2 == (\"c\", v1)      assert len(md) == 1      md.clear()      assert len(md) == 0      assert len(d) == 0      assert len(md_copy) == 3      v1 = \"\"      for k in md_copy:          v1 += k      assert v1 == \"abc\"      v1 = \"\"      for k in md_copy.keys():          v1 += k      assert v1 == \"abc\"      v1 = \"\"      for k in md_copy.__reversed__():          v1 += k      assert v1 == \"cba\"      v1 = 0      for k in md_copy.values():          v1 += k      assert v1 == 6  # 1+2+3      v1 = md_copy.setdefault(\"a\", 5)      assert v1 == 1      v1 = md_copy.setdefault(\"d\", 5)      assert v1 == 5        try:          md = _MapDict(\"not_a_dict\")          assert False      except Exception:          assert True      pass      def test_map_dict_update():      update_values = {}        def update(k, v):          update_values[0] = k          update_values[1] = v          pass        d = {\"a\": 1, \"b\": \"2\"}      md = _MapDict(d, update)      md.__setitem__(\"a\", 3)      assert update_values[0] == \"a\"      assert update_values[1] == 3      pass      def test_map_dict_update_full_dictionary_1():      values = {\"a\": 1, \"b\": 2}      update_values = {\"a\": 3, \"b\": 5}      md = _MapDict(values)      assert md[\"a\"] == 1      assert md[\"b\"] == 2      md.update(update_values)      assert md[\"a\"] == 3      assert md[\"b\"] == 5      def test_map_dict_update_full_dictionary_2():      temp_values = {}        def update(k, v):          temp_values[k] = v        values = {\"a\": 1, \"b\": 2}      update_values = {\"a\": 3, \"b\": 5}      md = _MapDict(values, update)      assert md[\"a\"] == 1      assert md[\"b\"] == 2      md.update(update_values)      assert temp_values[\"a\"] == 3      assert temp_values[\"b\"] == 5      def test_map_dict_set(gui: Gui, test_client):      d = {\"a\": 1}  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        gui.run(run_server=False, single_client=True)      with gui.get_flask_app().app_context():          assert isinstance(gui._Gui__state.d, _MapDict)          gui._Gui__state.d = {\"b\": 2}          assert isinstance(gui._Gui__state.d, _MapDict)          assert len(gui._Gui__state.d) == 1          assert gui._Gui__state.d.get(\"a\", None) is None          assert gui._Gui__state.d.get(\"b\", None) == 2      def test_map_dict_items():      def update(k, v):          pass        values = {\"a\": 1, \"b\": {\"c\": \"list c\"}}      md = _MapDict(values)      mdu = _MapDict(values, update)      assert md[\"a\"] == 1      assert isinstance(md[\"b\"], _MapDict)      assert isinstance(mdu[\"b\"], _MapDict)      assert md[\"b\"][\"c\"] == \"list c\"      assert mdu[\"b\"][\"c\"] == \"list c\"      del md[\"a\"]      with pytest.raises(KeyError):          md[\"e\"]      setattr(md, \"a\", 1)      assert md[\"a\"] == 1 "}
{"text": "import pathlib  import tempfile    from taipy.gui import Gui  from taipy.gui.utils import _get_non_existent_file_path      def test_empty_file_name(gui: Gui, helpers):      assert _get_non_existent_file_path(pathlib.Path(tempfile.gettempdir()), \"\").name      def test_non_existent_file(gui: Gui, helpers):      assert not _get_non_existent_file_path(pathlib.Path(tempfile.gettempdir()), \"\").exists()      def test_existent_file(gui: Gui, helpers):      file_path = _get_non_existent_file_path(pathlib.Path(tempfile.gettempdir()), \"\")      with open(file_path, \"w\") as file_handler:          file_handler.write(\"hello\")      assert file_path.exists()      file_stem = file_path.stem.split(\".\", 1)[0]      file_suffix = file_path.suffixes[-1]      index = int(file_path.suffixes[0][1:]) if len(file_path.suffixes) > 1 else -1      file_path = _get_non_existent_file_path(pathlib.Path(tempfile.gettempdir()), \"\")      assert file_path.name == f\"{file_stem}.{index + 1}{file_suffix}\"      with open(file_path, \"w\") as file_handler:          file_handler.write(\"hello 2\")      assert file_path.exists()      file_path = _get_non_existent_file_path(pathlib.Path(tempfile.gettempdir()), \"\")      assert file_path.name == f\"{file_stem}.{index + 2}{file_suffix}\" "}
{"text": "  import warnings    import pytest    from taipy.gui.utils.date import _string_to_date  from taipy.gui.utils.types import _TaipyBase, _TaipyBool, _TaipyDate, _TaipyNumber      def test_taipy_base():      tb = _TaipyBase(\"value\", \"hash\")      assert tb.get() == \"value\"      assert tb.get_name() == \"hash\"      tb.set(\"a value\")      assert tb.get() == \"a value\"      assert tb.get_hash() == NotImplementedError      def test_taipy_bool():      assert _TaipyBool(0, \"v\").get() is False      assert _TaipyBool(1, \"v\").get() is True      assert _TaipyBool(False, \"v\").get() is False      assert _TaipyBool(True, \"v\").get() is True      assert _TaipyBool(\"\", \"v\").get() is False      assert _TaipyBool(\"hey\", \"v\").get() is True      assert _TaipyBool([], \"v\").get() is False      assert _TaipyBool([\"an item\"], \"v\").get() is True      def test_taipy_number():      with pytest.raises(TypeError):          _TaipyNumber(\"a string\", \"x\").get()      with warnings.catch_warnings(record=True):          _TaipyNumber(\"a string\", \"x\").cast_value(\"a string\")      _TaipyNumber(0, \"x\").cast_value(0)      def test_taipy_date():      assert _TaipyDate(_string_to_date(\"2022-03-03 00:00:00 UTC\"), \"x\").get() == \"2022-03-03T00:00:00+00:00\"      assert _TaipyDate(\"2022-03-03 00:00:00 UTC\", \"x\").get() == \"2022-03-03 00:00:00 UTC\"      assert _TaipyDate(None, \"x\").get() is None      _TaipyDate(\"\", \"x\").cast_value(\"2022-03-03 00:00:00 UTC\")      _TaipyDate(\"\", \"x\").cast_value(_string_to_date(\"2022-03-03 00:00:00 UTC\")) "}
{"text": "import inspect  from time import sleep    import pytest    from taipy.gui import Gui, State, invoke_long_callback      def test_long_callback(gui: Gui):      status = None  # noqa: F841        def heavy_function(delay=1):          sleep(delay)        def heavy_function_with_exception(delay=1):          sleep(delay)          raise Exception(\"Heavy function Exception\")        def heavy_function_status(state: State, status: int):          state.status = status        def on_exception(state: State, function_name: str, e: Exception):          state.status = -1        gui._set_frame(inspect.currentframe())      gui.run(run_server=False, single_client=True)      state = gui._Gui__state        with gui.get_flask_app().app_context():          assert state.status is None          invoke_long_callback(state, heavy_function)          invoke_long_callback(state, heavy_function_with_exception)          invoke_long_callback(state, heavy_function, (), heavy_function_status)          invoke_long_callback(state, heavy_function, (2), heavy_function_status, (), 1000)          invoke_long_callback(state, heavy_function_with_exception, (), heavy_function_status) "}
{"text": "import inspect    from flask import g    from taipy.gui import Gui, Markdown, get_state_id      def test_get_state_id(gui: Gui, helpers):      name = \"World!\"  # noqa: F841      btn_id = \"button1\"  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|Hello {name}|button|id={btn_id}|>\"))      gui.run(run_server=False)      flask_client = gui._server.test_client()      cid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={cid}\")      with gui.get_flask_app().app_context():          g.client_id = cid          assert cid == get_state_id(gui._Gui__state) "}
{"text": "import inspect    from flask import g    from taipy.gui import Gui, Markdown, State, download      def test_download(gui: Gui, helpers):      name = \"World!\"  # noqa: F841      btn_id = \"button1\"  # noqa: F841        def on_download_action(state: State):          pass        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|Hello {name}|button|id={btn_id}|>\"))      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      cid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={cid}\")      with gui.get_flask_app().test_request_context(f\"/taipy-jsx/test/?client_id={cid}\", data={\"client_id\": cid}):          g.client_id = cid          download(gui._Gui__state, \"some text\", \"filename.txt\", \"on_download_action\")        received_messages = ws_client.get_received()      helpers.assert_outward_ws_simple_message(          received_messages[0], \"DF\", {\"name\": \"filename.txt\", \"onAction\": \"on_download_action\"}      ) "}
{"text": "import inspect    from flask import g    from taipy.gui import Gui, Markdown, navigate      def test_navigate(gui: Gui, helpers):      name = \"World!\"  # noqa: F841      btn_id = \"button1\"  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|Hello {name}|button|id={btn_id}|>\"))      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      cid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={cid}\")      with gui.get_flask_app().test_request_context(f\"/taipy-jsx/test/?client_id={cid}\", data={\"client_id\": cid}):          g.client_id = cid          navigate(gui._Gui__state, \"test\")        received_messages = ws_client.get_received()      helpers.assert_outward_ws_simple_message(received_messages[0], \"NA\", {\"to\": \"test\"}) "}
{"text": "import inspect    from flask import g    from taipy.gui import Gui, Markdown, State, invoke_callback      def test_invoke_callback(gui: Gui, helpers):      name = \"World!\"  # noqa: F841      btn_id = \"button1\"  # noqa: F841        val = 1  # noqa: F841        def user_callback(state: State):          state.val = 10        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|Hello {name}|button|id={btn_id}|>\\n<|{val}|>\"))      gui.run(run_server=False, single_client=True)      flask_client = gui._server.test_client()      # client id      cid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={cid}\")      with gui.get_flask_app().app_context():          g.client_id = cid          invoke_callback(gui, cid, user_callback, [])          assert gui._Gui__state.val == 10 "}
{"text": "import inspect    from flask import g    from taipy.gui import Gui, Markdown, hold_control      def test_hold_control(gui: Gui, helpers):      name = \"World!\"  # noqa: F841      btn_id = \"button1\"  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|Hello {name}|button|id={btn_id}|>\"))      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      cid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={cid}\")      with gui.get_flask_app().test_request_context(f\"/taipy-jsx/test/?client_id={cid}\", data={\"client_id\": cid}):          g.client_id = cid          hold_control(gui._Gui__state)        received_messages = ws_client.get_received()      helpers.assert_outward_ws_simple_message(          received_messages[0], \"BL\", {\"action\": \"_taipy_on_cancel_block_ui\", \"message\": \"Work in Progress...\"}      ) "}
{"text": "import inspect    from flask import g    from taipy.gui import Gui, Markdown, resume_control      def test_resume_control(gui: Gui, helpers):      name = \"World!\"  # noqa: F841      btn_id = \"button1\"  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|Hello {name}|button|id={btn_id}|>\"))      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      cid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={cid}\")      with gui.get_flask_app().test_request_context(f\"/taipy-jsx/test/?client_id={cid}\", data={\"client_id\": cid}):          g.client_id = cid          resume_control(gui._Gui__state)        received_messages = ws_client.get_received()      helpers.assert_outward_ws_simple_message(received_messages[0], \"BL\", {\"message\": None}) "}
{"text": "import inspect    from flask import g    from taipy.gui import Gui, Markdown, notify      def test_notify(gui: Gui, helpers):      name = \"World!\"  # noqa: F841      btn_id = \"button1\"  # noqa: F841        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", Markdown(\"<|Hello {name}|button|id={btn_id}|>\"))      gui.run(run_server=False)      flask_client = gui._server.test_client()      # WS client and emit      ws_client = gui._server._ws.test_client(gui._server.get_flask())      cid = helpers.create_scope_and_get_sid(gui)      # Get the jsx once so that the page will be evaluated -> variable will be registered      flask_client.get(f\"/taipy-jsx/test?client_id={cid}\")      with gui.get_flask_app().test_request_context(f\"/taipy-jsx/test/?client_id={cid}\", data={\"client_id\": cid}):          g.client_id = cid          notify(gui._Gui__state, \"Info\", \"Message\")        received_messages = ws_client.get_received()      helpers.assert_outward_ws_simple_message(received_messages[0], \"AL\", {\"atype\": \"Info\", \"message\": \"Message\"}) "}
{"text": "import contextlib  import time  from urllib.request import urlopen    import pytest  from testbook import testbook      @pytest.mark.filterwarnings(\"ignore::RuntimeWarning\")  @testbook(\"tests/taipy/gui/notebook/simple_gui.ipynb\")  def test_notebook_simple_gui(tb, helpers):      tb.execute_cell(\"import\")      tb.execute_cell(\"page_declaration\")      tb.execute_cell(\"gui_init\")      tb.execute_cell(\"gui_run\")      while not helpers.port_check():          time.sleep(0.1)      assert \">Hello</h1>\" in urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\").read().decode(\"utf-8\")      assert 'defaultValue=\\\\\"10\\\\\"' in urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\").read().decode(\"utf-8\")      # Test state manipulation within notebook      tb.execute_cell(\"get_variable\")      assert \"10\" in tb.cell_output_text(\"get_variable\")      assert 'defaultValue=\\\\\"10\\\\\"' in urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\").read().decode(\"utf-8\")      tb.execute_cell(\"set_variable\")      assert 'defaultValue=\\\\\"20\\\\\"' in urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\").read().decode(\"utf-8\")      tb.execute_cell(\"re_get_variable\")      assert \"20\" in tb.cell_output_text(\"re_get_variable\")      # Test page reload      tb.execute_cell(\"gui_stop\")      with pytest.raises(Exception) as exc_info:          urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\")      assert \"501: Gateway error\" in str(exc_info.value)      tb.execute_cell(\"gui_re_run\")      while True:          with contextlib.suppress(Exception):              urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\")              break      assert \">Hello</h1>\" in urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\").read().decode(\"utf-8\")      tb.execute_cell(\"gui_reload\")      while True:          with contextlib.suppress(Exception):              urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\")              break      assert \">Hello</h1>\" in urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\").read().decode(\"utf-8\")      tb.execute_cell(\"gui_re_stop\")      with pytest.raises(Exception) as exc_info:          urlopen(\"http://127.0.0.1:5000/taipy-jsx/page1\")      assert \"501: Gateway error\" in str(exc_info.value) "}
{"text": "from taipy.gui import Gui, Markdown "}
{"text": "import inspect  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      @pytest.mark.teste2e  def test_redirect(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|Redirect Successfully|id=text1|>  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui)      page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      text1 = page.query_selector(\"#text1\")      assert text1.inner_text() == \"Redirect Successfully\" "}
{"text": "import pytest      @pytest.fixture(scope=\"session\")  def browser_context_args(browser_context_args, e2e_port, e2e_base_url):      return {          **browser_context_args,          \"base_url\": f\"http://127.0.0.1:{e2e_port}{e2e_base_url}\",          \"timezone_id\": \"Europe/Paris\",      }      @pytest.fixture(scope=\"function\")  def gui(helpers, e2e_base_url):      from taipy.gui import Gui        gui = Gui()      gui.load_config({\"base_url\": e2e_base_url, \"host\": \"0.0.0.0\" if e2e_base_url != \"/\" else \"127.0.0.1\"})      yield gui      # Delete Gui instance and state of some classes after each test      gui.stop()      helpers.test_cleanup() "}
{"text": "import inspect  import re  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page      from playwright.sync_api import expect    from taipy.gui import Gui      @pytest.mark.teste2e  def test_navbar_navigate(page: \"Page\", gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"Data\", page=\"<|navbar|id=nav1|> <|Data|id=text-data|>\")      gui.add_page(name=\"Test\", page=\"<|navbar|id=nav1|> <|Test|id=text-test|>\")      helpers.run_e2e(gui)      page.goto(\"./Data\")      page.expect_websocket()      page.wait_for_selector(\"#text-data\")      page.click(\"#nav1 button:nth-child(2)\")      page.wait_for_selector(\"#text-test\")      expect(page).to_have_url(re.compile(\".*Test\"))      page.click(\"#nav1 button:nth-child(1)\")      page.wait_for_selector(\"#text-data\")      expect(page).to_have_url(re.compile(\".*Data\")) "}
{"text": "import inspect  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui  from taipy.gui.utils.date import _string_to_date      @pytest.mark.teste2e  def test_timzone_specified_1(page: \"Page\", gui: Gui, helpers):      _timezone_test_template(page, gui, helpers, \"Etc/GMT\", [\"2022-03-03 00:00:00 UTC\"])      @pytest.mark.teste2e  def test_timzone_specified_2(page: \"Page\", gui: Gui, helpers):      _timezone_test_template(          page, gui, helpers, \"Europe/Paris\", [\"2022-03-03 01:00:00 GMT+1\", \"2022-03-03 01:00:00 UTC+1\"]      )      @pytest.mark.teste2e  def test_timzone_specified_3(page: \"Page\", gui: Gui, helpers):      _timezone_test_template(          page, gui, helpers, \"Asia/Ho_Chi_Minh\", [\"2022-03-03 07:00:00 GMT+7\", \"2022-03-03 07:00:00 UTC+7\"]      )      @pytest.mark.teste2e  def test_timzone_specified_4(page: \"Page\", gui: Gui, helpers):      _timezone_test_template(          page, gui, helpers, \"America/Sao_Paulo\", [\"2022-03-02 21:00:00 GMT-3\", \"2022-03-02 21:00:00 UTC\u22123\"]      )      @pytest.mark.teste2e  def test_timezone_client_side(page: \"Page\", gui: Gui, helpers):      _timezone_test_template(page, gui, helpers, \"client\", [\"2022-03-03 01:00:00 GMT+1\", \"2022-03-03 01:00:00 UTC+1\"])      def _timezone_test_template(page: \"Page\", gui: Gui, helpers, time_zone, texts):      page_md = \"\"\"  <|{t}|id=text1|>  \"\"\"      t = _string_to_date(\"2022-03-03T00:00:00.000Z\")  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui, time_zone=time_zone)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      text1 = page.query_selector(\"#text1\")      assert text1.inner_text() in texts      def test_date_only(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|{t}|id=text1|>  \"\"\"      t = _string_to_date(\"Wed Jul 28 1993\")  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      text1 = page.query_selector(\"#text1\")      assert text1.inner_text() in [\"1993-07-28\"] "}
{"text": "import inspect  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      @pytest.mark.teste2e  def test_accessor_json(page: \"Page\", gui: Gui, csvdata, helpers):      table_data = csvdata  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.add_page(          name=\"test\",          page=\"<|{table_data}|table|columns=Day;Entity;Code;Daily hospital occupancy|date_format=eee dd MMM yyyy|id=table1|>\",      )      helpers.run_e2e(gui, use_arrow=False)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"#table1 tr:nth-child(32)\")  # wait for data to be loaded (30 rows of skeleton while loading)      assert_table_content(page)      @pytest.mark.teste2e  def test_accessor_arrow(page: \"Page\", gui: Gui, csvdata, helpers):      if util.find_spec(\"pyarrow\"):          table_data = csvdata  # noqa: F841          gui._set_frame(inspect.currentframe())          gui.add_page(              name=\"test\",              page=\"<|{table_data}|table|columns=Day;Entity;Code;Daily hospital occupancy|date_format=eee dd MMM yyyy|id=table1|>\",          )          helpers.run_e2e(gui, use_arrow=True)          page.goto(\"./test\")          page.expect_websocket()          page.wait_for_selector(              \"#table1 tr:nth-child(32)\"          )  # wait for data to be loaded (30 rows of skeleton while loading)          assert_table_content(page)      def assert_table_content(page: \"Page\"):      # assert page.query_selector(\"#table1 tbody tr:nth-child(1) td:nth-child(1)\").inner_text() == \"Wed 01 Apr 2020\"      assert page.query_selector(\"#table1 tbody tr:nth-child(1) td:nth-child(2)\").inner_text() == \"Austria\"      assert page.query_selector(\"#table1 tbody tr:nth-child(1) td:nth-child(4)\").inner_text() == \"856\" "}
{"text": "import inspect  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      @pytest.mark.teste2e  def test_theme_light(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|Just a page|id=text1|>  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui, dark_mode=False)      page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      background_color = page.evaluate(          'window.getComputedStyle(document.querySelector(\"main\"), null).getPropertyValue(\"background-color\")'      )      assert background_color == \"rgb(255, 255, 255)\"      @pytest.mark.teste2e  def test_theme_dark(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|Just a page|id=text1|>  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui, dark_mode=True)      page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      background_color = page.evaluate(          'window.getComputedStyle(document.querySelector(\"main\"), null).getPropertyValue(\"background-color\")'      )      assert background_color == \"rgb(18, 18, 18)\" "}
{"text": "import inspect  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      @pytest.mark.teste2e  def test_margin_1(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|Just a page|id=text1|>  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui, dark_mode=False, margin=\"10rem\")      page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      margin = page.evaluate('window.getComputedStyle(document.querySelector(\"#root\"), null).getPropertyValue(\"margin\")')      assert margin == \"160px\"      @pytest.mark.teste2e  def test_margin_2(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|Just a page|id=text1|>  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui, dark_mode=False)      page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      margin = page.evaluate('window.getComputedStyle(document.querySelector(\"#root\"), null).getPropertyValue(\"margin\")')      assert margin == \"16px\"      @pytest.mark.teste2e  def test_margin_3(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|Just a page|id=text1|>  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui, dark_mode=False, margin=\"10rem\", stylekit=True)      page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      margin = page.evaluate('window.getComputedStyle(document.querySelector(\"#root\"), null).getPropertyValue(\"margin\")')      assert margin == \"160px\"      @pytest.mark.teste2e  def test_margin_4(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|Just a page|id=text1|>  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui, dark_mode=False, stylekit={\"root_margin\": \"20rem\"})      page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      margin = page.evaluate('window.getComputedStyle(document.querySelector(\"#root\"), null).getPropertyValue(\"margin\")')      assert margin == \"320px\"      @pytest.mark.teste2e  def test_margin_5(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|Just a page|id=text1|>  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui, dark_mode=False, stylekit={\"root_margin\": \"20rem\"}, margin=\"10rem\")      page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      margin = page.evaluate('window.getComputedStyle(document.querySelector(\"#root\"), null).getPropertyValue(\"margin\")')      assert margin == \"320px\" "}
{"text": "import inspect  import os  import time  from importlib import util  from pathlib import Path  from urllib.request import urlopen    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui, Html  from taipy.gui.server import _Server      @pytest.mark.teste2e  def test_html_render_with_style(page: \"Page\", gui: Gui, helpers):      html_content = \"\"\"<!DOCTYPE html>  <html lang=\"en\">  <head>      <style>          .taipy-text {              color: green;          }          .custom-text {              color: blue;          }      </style>  </head>  <body>      <taipy:text id=\"text1\">Hey</taipy:text>      <taipy:text id=\"text2\" class=\"custom-text\">There</taipy:text>  </body>  </html>\"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(\"page1\", Html(html_content))      helpers.run_e2e(gui)      page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      retry = 0      while (          retry < 10          and page.evaluate('window.getComputedStyle(document.querySelector(\"#text1\"), null).getPropertyValue(\"color\")')          != \"rgb(0, 128, 0)\"      ):          retry += 1          time.sleep(0.2)      assert (          page.evaluate('window.getComputedStyle(document.querySelector(\"#text1\"), null).getPropertyValue(\"color\")')          == \"rgb(0, 128, 0)\"      )      assert (          page.evaluate('window.getComputedStyle(document.querySelector(\"#text2\"), null).getPropertyValue(\"color\")')          == \"rgb(0, 0, 255)\"      )      @pytest.mark.teste2e  def test_html_render_bind_assets(page: \"Page\", gui: Gui, helpers, e2e_base_url, e2e_port):      gui._set_frame(inspect.currentframe())      gui.add_pages(pages=f\"{Path(Path(__file__).parent.resolve())}{os.path.sep}test-assets\")      helpers.run_e2e(gui)      assert \".taipy-text\" in urlopen(          f\"http://127.0.0.1:{e2e_port}{e2e_base_url}test-assets/style/style.css\"      ).read().decode(\"utf-8\")      page.goto(\"./test-assets/page1\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      retry = 0      while (          retry < 10          and page.evaluate('window.getComputedStyle(document.querySelector(\"#text1\"), null).getPropertyValue(\"color\")')          != \"rgb(0, 128, 0)\"      ):          retry += 1          time.sleep(0.1)      assert (          page.evaluate('window.getComputedStyle(document.querySelector(\"#text1\"), null).getPropertyValue(\"color\")')          == \"rgb(0, 128, 0)\"      )      assert (          page.evaluate('window.getComputedStyle(document.querySelector(\"#text2\"), null).getPropertyValue(\"color\")')          == \"rgb(0, 0, 255)\"      )      @pytest.mark.teste2e  def test_html_render_path_mapping(page: \"Page\", gui: Gui, helpers, e2e_base_url, e2e_port):      gui._server = _Server(          gui,          path_mapping={\"style\": f\"{Path(Path(__file__).parent.resolve())}{os.path.sep}test-assets{os.path.sep}style\"},          flask=gui._flask,          async_mode=\"gevent\",      )      gui.add_page(\"page1\", Html(f\"{Path(Path(__file__).parent.resolve())}{os.path.sep}page1.html\"))      helpers.run_e2e(gui)      assert \".taipy-text\" in urlopen(f\"http://127.0.0.1:{e2e_port}{e2e_base_url}/style/style.css\").read().decode(\"utf-8\")      page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      retry = 0      while (          retry < 10          and page.evaluate('window.getComputedStyle(document.querySelector(\"#text1\"), null).getPropertyValue(\"color\")')          != \"rgb(0, 128, 0)\"      ):          retry += 1          time.sleep(0.1)      assert (          page.evaluate('window.getComputedStyle(document.querySelector(\"#text1\"), null).getPropertyValue(\"color\")')          == \"rgb(0, 128, 0)\"      )      assert (          page.evaluate('window.getComputedStyle(document.querySelector(\"#text2\"), null).getPropertyValue(\"color\")')          == \"rgb(0, 0, 255)\"      ) "}
{"text": "import inspect  import logging  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      @pytest.mark.teste2e  def test_markdown_render_with_style(page: \"Page\", gui: Gui, helpers):      markdown_content = \"\"\"  <|Hey|id=text1|>  <|There|id=text2|class_name=custom-text|>  \"\"\"      style = \"\"\"  .taipy-text {      color: green;  }  .custom-text {      color: blue;  }  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(\"page1\", markdown_content, style=style)      helpers.run_e2e(gui)      page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      page.wait_for_selector(\"#Taipy_style\", state=\"attached\")      function_evaluated = True      try:          page.wait_for_function(              'window.getComputedStyle(document.querySelector(\"#text1\"), null).getPropertyValue(\"color\") !== \"rgb(255, 255, 255)\"'          )      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          assert (              page.evaluate('window.getComputedStyle(document.querySelector(\"#text1\"), null).getPropertyValue(\"color\")')              == \"rgb(0, 128, 0)\"          )          assert (              page.evaluate('window.getComputedStyle(document.querySelector(\"#text2\"), null).getPropertyValue(\"color\")')              == \"rgb(0, 0, 255)\"          ) "}
{"text": "import inspect  import logging  from importlib import util    import pytest    from taipy.gui import Gui    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from .assets2_class_scopes.page1 import Page1  from .assets2_class_scopes.page2 import Page2      def helpers_assert_value(page, s1, s2, v1):      s1_val = page.input_value(\"#s1 input\")      assert str(s1_val).startswith(s1)      s2_val = page.input_value(\"#s2 input\")      assert str(s2_val).startswith(s2)      val1 = page.query_selector(\"#v1\").inner_text()      assert str(val1).startswith(v1)      @pytest.mark.timeout(300)  @pytest.mark.teste2e  @pytest.mark.filterwarnings(\"ignore::Warning\")  def test_class_scopes_binding(page: \"Page\", gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      operand_1 = 0  # noqa: F841      gui.add_page(\"page1\", Page1())      gui.add_page(\"page2\", Page2())      helpers.run_e2e(gui)        page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#s1\")      helpers_assert_value(page, \"0\", \"0\", \"0\")      page.fill(\"#s1 input\", \"15\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#v1').innerText !== '0'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_value(page, \"15\", \"0\", \"15\")      page.fill(\"#s2 input\", \"20\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#v1').innerText !== '15'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_value(page, \"15\", \"20\", \"35\")        page.goto(\"./page2\")      page.expect_websocket()      page.wait_for_selector(\"#s1\")      helpers_assert_value(page, \"15\", \"0\", \"0\")      page.fill(\"#s2 input\", \"5\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#v1').innerText !== '0'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_value(page, \"15\", \"5\", \"75\")      page.fill(\"#s1 input\", \"17\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#v1').innerText !== '75'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_value(page, \"17\", \"5\", \"85\")        page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#s1\")      helpers_assert_value(page, \"17\", \"20\", \"37\")        page.click(\"#btn_reset\")      try:          page.wait_for_function(\"document.querySelector('#v1').innerText !== '37'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_value(page, \"17\", \"0\", \"17\") "}
{"text": "import inspect  import logging  from importlib import util    import pytest    from taipy.gui import Gui    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from .assets.page1 import page as page1  from .assets.page2 import page as page2  from .assets.page3 import page as page3      @pytest.mark.timeout(300)  @pytest.mark.teste2e  def test_page_scopes(page: \"Page\", gui: Gui, helpers):      gui._set_frame(inspect.currentframe())        def on_change(state, var, val, module):          if var == \"x\" and \"page3\" in module:              state.y = val * 10        gui.add_page(\"page1\", page1)      gui.add_page(\"page2\", page2)      gui.add_page(\"page3\", page3)      helpers.run_e2e(gui)        page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#x1\")      assert page.query_selector(\"#x1\").inner_text() == \"10\"      assert page.query_selector(\"#x2\").inner_text() == \"20\"      assert page.query_selector(\"#y1\").inner_text() == \"20\"      assert page.query_selector(\"#y2\").inner_text() == \"40\"        page.goto(\"./page2\")      page.expect_websocket()      page.wait_for_selector(\"#x1\")      assert page.query_selector(\"#x1\").inner_text() == \"20\"      assert page.query_selector(\"#x2\").inner_text() == \"40\"      assert page.query_selector(\"#y1\").inner_text() == \"10\"      assert page.query_selector(\"#y2\").inner_text() == \"20\"        page.goto(\"./page3\")      page.expect_websocket()      page.wait_for_selector(\"#x1\")      assert page.query_selector(\"#x1\").inner_text() == \"50\"      assert page.query_selector(\"#x2\").inner_text() == \"100\"        page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#x1\")      page.fill(\"#xinput\", \"15\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#y2').innerText !== '40'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      assert page.query_selector(\"#x1\").inner_text() == \"15\"      assert page.query_selector(\"#x2\").inner_text() == \"30\"      assert page.query_selector(\"#y1\").inner_text() == \"45\"      assert page.query_selector(\"#y2\").inner_text() == \"90\"        page.goto(\"./page2\")      page.expect_websocket()      page.wait_for_selector(\"#x1\")      assert page.query_selector(\"#x1\").inner_text() == \"45\"      assert page.query_selector(\"#x2\").inner_text() == \"90\"      assert page.query_selector(\"#y1\").inner_text() == \"15\"      assert page.query_selector(\"#y2\").inner_text() == \"30\"      page.fill(\"#xinput\", \"37\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#y2').innerText !== '30'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      assert page.query_selector(\"#x1\").inner_text() == \"37\"      assert page.query_selector(\"#x2\").inner_text() == \"74\"      assert page.query_selector(\"#y1\").inner_text() == \"185\"      assert page.query_selector(\"#y2\").inner_text() == \"370\"        page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#x1\")      assert page.query_selector(\"#x1\").inner_text() == \"185\"      assert page.query_selector(\"#x2\").inner_text() == \"370\"      assert page.query_selector(\"#y1\").inner_text() == \"37\"      assert page.query_selector(\"#y2\").inner_text() == \"74\"        page.goto(\"./page3\")      page.expect_websocket()      page.wait_for_selector(\"#x1\")      assert page.query_selector(\"#x1\").inner_text() == \"50\"      assert page.query_selector(\"#x2\").inner_text() == \"100\" "}
{"text": "import inspect  import logging  from importlib import util    import pytest    from taipy.gui import Gui, Markdown    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from .assets3.page1 import page as page1      def helpers_assert_text(page, s):      val1 = page.query_selector(\"#t1\").inner_text()      assert str(val1).startswith(s)      # for issue #583  @pytest.mark.teste2e  @pytest.mark.filterwarnings(\"ignore::Warning\")  def test_page_scopes_main_var_access(page: \"Page\", gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      n = \"Hello\"  # noqa: F841        root_md = Markdown(          \"\"\"    <|{n}|input|id=i1|>    \"\"\"      )      gui.add_pages({\"/\": root_md, \"page1\": page1})      helpers.run_e2e(gui)        page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#t1\")      page.wait_for_selector(\"#i1\")      helpers_assert_text(page, \"Hello\")      page.fill(\"#i1\", \"Hello World\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#t1').innerText !== 'Hello'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_text(page, \"Hello World\") "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import inspect  import logging  from importlib import util    import pytest    from taipy.gui import Gui, Markdown    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from .assets3_class_scopes.page1 import Page1      def helpers_assert_text(page, s):      val1 = page.query_selector(\"#t1\").inner_text()      assert str(val1).startswith(s)      # for issue #583  @pytest.mark.teste2e  @pytest.mark.filterwarnings(\"ignore::Warning\")  def test_class_scopes_main_var_access(page: \"Page\", gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      n = \"Hello\"  # noqa: F841        root_md = Markdown(          \"\"\"    <|{n}|input|id=i1|>    \"\"\"      )      gui.add_pages({\"/\": root_md, \"page1\": Page1()})      helpers.run_e2e(gui)        page.goto(\"./\")      page.expect_websocket()      page.wait_for_selector(\"#t1\")      page.wait_for_selector(\"#i1\")      helpers_assert_text(page, \"Hello\")      page.fill(\"#i1\", \"Hello World\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#t1').innerText !== 'Hello'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_text(page, \"Hello World\") "}
{"text": "import inspect  import logging  from importlib import util    import pytest    from taipy.gui import Gui    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from .assets4.page1 import page as page1  from .assets4.page1 import reset_d      @pytest.mark.timeout(300)  @pytest.mark.teste2e  @pytest.mark.filterwarnings(\"ignore::Warning\")  def test_page_scopes_state_runtime(page: \"Page\", gui: Gui, helpers):      gui._set_frame(inspect.currentframe())        def test(state):          reset_d(state)        def test2(state):          state[\"page1\"].d = 30        page_md = \"\"\"  <|button|on_action=test|id=btn1|>    <|button|on_action=test2|id=btn2|>  \"\"\"      gui.add_page(\"page1\", page1)      gui.add_page(name=Gui._get_root_page_name(), page=page_md)      helpers.run_e2e(gui)        page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#n1\")      text1 = page.query_selector(\"#t1\")      assert text1.inner_text() == \"20\"      page.fill(\"#n1\", \"21\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#t1').innerText !== '20'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      text1 = page.query_selector(\"#t1\")      assert text1.inner_text() == \"21\"        page.click(\"#btn1\")      try:          page.wait_for_function(\"document.querySelector('#t1').innerText !== '21'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      text1 = page.query_selector(\"#t1\")      assert text1.inner_text() == \"20\"        page.click(\"#btn2\")      try:          page.wait_for_function(\"document.querySelector('#t1').innerText !== '20'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      text1 = page.query_selector(\"#t1\")      assert text1.inner_text() == \"30\" "}
{"text": "import inspect  import logging  from importlib import util    import pytest    from taipy.gui import Gui    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from .assets2.page1 import page as page1  from .assets2.page2 import page as page2      def helpers_assert_value(page, s1, s2, v1):      s1_val = page.input_value(\"#s1 input\")      assert str(s1_val).startswith(s1)      s2_val = page.input_value(\"#s2 input\")      assert str(s2_val).startswith(s2)      val1 = page.query_selector(\"#v1\").inner_text()      assert str(val1).startswith(v1)      @pytest.mark.timeout(300)  @pytest.mark.teste2e  @pytest.mark.filterwarnings(\"ignore::Warning\")  def test_page_scopes_binding(page: \"Page\", gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      operand_1 = 0  # noqa: F841      gui.add_page(\"page1\", page1)      gui.add_page(\"page2\", page2)      helpers.run_e2e(gui)        page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#s1\")      helpers_assert_value(page, \"0\", \"0\", \"0\")      page.fill(\"#s1 input\", \"15\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#v1').innerText !== '0'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_value(page, \"15\", \"0\", \"15\")      page.fill(\"#s2 input\", \"20\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#v1').innerText !== '15'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_value(page, \"15\", \"20\", \"35\")        page.goto(\"./page2\")      page.expect_websocket()      page.wait_for_selector(\"#s1\")      helpers_assert_value(page, \"15\", \"0\", \"0\")      page.fill(\"#s2 input\", \"5\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#v1').innerText !== '0'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_value(page, \"15\", \"5\", \"75\")      page.fill(\"#s1 input\", \"17\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#v1').innerText !== '75'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      helpers_assert_value(page, \"17\", \"5\", \"85\")        page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#s1\")      helpers_assert_value(page, \"17\", \"20\", \"37\") "}
{"text": "from taipy.gui import Markdown, Page      class Page1(Page):      def __init__(self):          self.operand_2 = 0          super().__init__()        def create_page(self):          return Markdown(\"page1.md\")        def reset(state):          state.operand_2 = 0 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from taipy.gui import Markdown, Page      class Page2(Page):      def __init__(self):          self.operand_2 = 0          super().__init__()        def create_page(self):          return Markdown(\"page2.md\") "}
{"text": "from taipy.gui import Markdown, Page      class Page1(Page):      def create_page(self):          return Markdown(              \"\"\"    <|{n}|id=t1|>    \"\"\"          ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from taipy.gui import Markdown    x = 10    y = 20      def on_change(state, var, val):      if var == \"x\":          state.y = val * 3      page = Markdown(      \"\"\"  x = <|{x}|id=x1|>    x * 2 = <|{x*2}|id=x2|>    x number: <|{x}|number|id=xinput|>    y = <|{y}|id=y1|>    y * 2 = <|{y*2}|id=y2|>  \"\"\"  ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from taipy.gui import Markdown    from .page1 import x as y  from .page1 import y as x      def on_change(state, var, val):      if var == \"x\":          state.y = val * 5      page = Markdown(      \"\"\"  y = <|{x}|id=x1|>    y * 2 = <|{x*2}|id=x2|>    y number: <|{x}|number|id=xinput|>    x = <|{y}|id=y1|>    x * 2 = <|{y*2}|id=y2|>  \"\"\"  ) "}
{"text": "from taipy.gui import Markdown    x = 50    page = Markdown(      \"\"\"  <|{x}|id=x1|>    x * 2 = <|{x*2}|id=x2|>    <|{x}|number|id=xinput|>  \"\"\"  ) "}
{"text": "from taipy.gui import Markdown    page = Markdown(      \"\"\"    # Page1 - Add    Operand 1: <|{operand_1}|slider|id=s1|>    Operand 2: <|{operand_2}|slider|id=s2|>    Operand 1 + Operand 2 = <|{operand_1 + operand_2}|id=v1|>  \"\"\"  )    operand_2 = 0 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from taipy.gui import Markdown    page = Markdown(      \"\"\"    # Page2 - Multiply    Operand 1: <|{operand_1}|slider|id=s1|>    Operand 2: <|{operand_2}|slider|id=s2|>    Operand 1 * Operand 2 = <|{operand_1 * operand_2}|id=v1|>  \"\"\"  )    operand_2 = 0 "}
{"text": "from taipy.gui import Markdown    d = 20      def reset_d(state):      state.d = d  # a      page = Markdown(      \"\"\"    <|{d}|text|id=t1|>    <|{d}|number|id=n1|>    \"\"\"  ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from taipy.gui import Markdown    page = Markdown(      \"\"\"    <|{n}|id=t1|>    \"\"\"  ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import inspect  import logging  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      @pytest.mark.teste2e  def test_slider_action(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|{x}|id=text1|>    <|{x}|slider|id=slider1|>  \"\"\"      x = 10  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      text1 = page.query_selector(\"#text1\")      assert text1.inner_text() == \"10\"      page.wait_for_selector(\"#slider1\")      page.fill(\"#slider1 input\", \"20\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#text1').innerText !== '10'\")      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          text1_2 = page.query_selector(\"#text1\")          assert text1_2.inner_text() == \"20\"      @pytest.mark.teste2e  def test_slider_action_on_change(page: \"Page\", gui: Gui, helpers):      d = {\"v1\": 10, \"v2\": 10}  # noqa: F841        def on_change(state, var, val):          if var == \"d.v2\":              d = {\"v1\": 2 * val}              state.d.update(d)        page_md = \"\"\"  Value: <|{d.v1}|id=text1|>    Slider: <|{d.v2}|slider|id=slider1|>  \"\"\"      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      text1 = page.query_selector(\"#text1\")      assert text1.inner_text() == \"10\"      page.wait_for_selector(\"#slider1\")      page.fill(\"#slider1 input\", \"20\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#text1').innerText !== '10'\")      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          text1_2 = page.query_selector(\"#text1\")          assert text1_2.inner_text() == \"40\" "}
{"text": "import inspect  import logging  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      @pytest.mark.teste2e  def test_button_action(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|{x}|id=text1|>    <|Action|button|on_action=do_something_fn|id=button1|>  \"\"\"      x = 10  # noqa: F841        def do_something_fn(state):          state.x = state.x * 2        gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      text1 = page.query_selector(\"#text1\")      assert text1.inner_text() == \"10\"      page.click(\"#button1\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#text1').innerText !== '10'\")      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          text1_2 = page.query_selector(\"#text1\")          assert text1_2.inner_text() == \"20\" "}
{"text": "import inspect  import time  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui, State      @pytest.mark.teste2e  def test_selector_action(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|{x}|selector|lov=Item 1;Item 2;Item 3|id=selector1|>  \"\"\"      x = \"Item 1\"  # noqa: F841        def on_init(state: State):          assert state.x == \"Item 1\"        def on_change(state: State, var, val):          if var == \"x\":              assert val == \"Item 3\"        gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"ul#selector1\")      page.click('#selector1 > div[data-id=\"Item 3\"]')      page.wait_for_function(          \"document.querySelector('#selector1 > div[data-id=\\\"Item 3\\\"]').classList.contains('Mui-selected')\"      ) "}
{"text": "import inspect  import logging  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      def edit_and_assert_page(page: \"Page\"):      assert_input(page, \"0\")        page.fill(\"#input2 input\", \"20\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#val1').innerText !== '0'\")      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      assert_input(page, \"20\")        page.fill(\"#input1\", \"30\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#val1').innerText !== '20'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if not function_evaluated:          return      assert_input(page, \"30\")      def assert_input(page: \"Page\", val: str):      val1 = page.query_selector(\"#val1\").inner_text()      assert str(val1).startswith(val)      val2 = page.query_selector(\"#val2\").inner_text()      assert str(val2).startswith(f\"Val: {val}\")      inp1 = page.input_value(\"input#input1\")      assert str(inp1).startswith(val)      inp2 = page.input_value(\"#input2 input\")      assert str(inp2).startswith(val)      @pytest.mark.filterwarnings(\"ignore::Warning\")  @pytest.mark.teste2e  def test_slider_input_reload(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  #Test Multi Number    <|{val}|id=val1|>    <|Val: {val}|id=val2|>    <|{val}|number|id=input1|>    <|{val}|slider|id=input2|>  \"\"\"      val = 0  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"page1\", page=page_md)      helpers.run_e2e_multi_client(gui)      page.goto(\"./page1\")      page.expect_websocket()      page.wait_for_selector(\"#val1\")      edit_and_assert_page(page)        page.reload()      page.expect_websocket()      page.wait_for_selector(\"#val1\")      assert_input(page, \"30\")        page.evaluate(\"window.localStorage.removeItem('TaipyClientId')\")        page.reload()      page.expect_websocket()      page.wait_for_selector(\"#val1\")      assert_input(page, \"0\") "}
{"text": "import inspect  import logging  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      @pytest.mark.teste2e  def test_dict(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|{a_dict[a_key]}|input|id=inp1|>  <|{a_dict.key}|input|id=inp2|>  <|test|button|on_action=on_action_1|id=btn1|>  <|test|button|on_action=on_action_2|id=btn2|>  \"\"\"      a_key = \"key\"      a_dict = {a_key: \"Taipy\"}  # noqa: F841        def on_action_1(state):          state.a_dict.key = \"Hello\"        def on_action_2(state):          state.a_dict[state.a_key] = \"World\"        gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"#inp1\")        assert_text(page, \"Taipy\", \"Taipy\")        page.fill(\"input#inp1\", \"Taipy is the best\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#inp2').value !== 'Taipy'\")      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          assert_text(page, \"Taipy is the best\", \"Taipy is the best\")        page.fill(\"#inp2\", \"Taipy-Gui\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#inp1').value !== 'Taipy is the best'\")      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          assert_text(page, \"Taipy-Gui\", \"Taipy-Gui\")        page.click(\"#btn1\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#inp1').value !== 'Taipy-Gui'\")      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          assert_text(page, \"Hello\", \"Hello\")        page.click(\"#btn2\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#inp1').value !== 'Hello'\")      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          assert_text(page, \"World\", \"World\")      def assert_text(page, inp1, inp2):      assert page.input_value(\"input#inp1\") == inp1      assert page.input_value(\"input#inp2\") == inp2 "}
{"text": "import inspect  import logging  from importlib import util    import pytest    if util.find_spec(\"playwright\"):      from playwright._impl._page import Page    from taipy.gui import Gui      @pytest.mark.teste2e  def test_text_edit(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|{x}|text|id=text1|>    <|{x}|input|id=input1|>  \"\"\"      x = \"Hey\"  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      text1 = page.query_selector(\"#text1\")      assert text1.inner_text() == \"Hey\"      page.wait_for_selector(\"#input1\")      page.fill(\"#input1\", \"There\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#text1').innerText !== 'Hey'\")      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          text1_2 = page.query_selector(\"#text1\")          assert text1_2.inner_text() == \"There\"      @pytest.mark.teste2e  def test_number_edit(page: \"Page\", gui: Gui, helpers):      page_md = \"\"\"  <|{x}|text|id=text1|>    <|{x}|number|id=number1|>    \"\"\"      x = 10  # noqa: F841      gui._set_frame(inspect.currentframe())      gui.add_page(name=\"test\", page=page_md)      helpers.run_e2e(gui)      page.goto(\"./test\")      page.expect_websocket()      page.wait_for_selector(\"#text1\")      text1 = page.query_selector(\"#text1\")      assert text1.inner_text() == \"10\"      page.wait_for_selector(\"#number1\")      page.fill(\"#number1\", \"20\")      function_evaluated = True      try:          page.wait_for_function(\"document.querySelector('#text1').innerText !== '10'\")          function_evaluated = True      except Exception as e:          function_evaluated = False          logging.getLogger().debug(f\"Function evaluation timeout.\\n{e}\")      if function_evaluated:          text1_2 = page.query_selector(\"#text1\")          assert text1_2.inner_text() == \"20\" "}
{"text": "from importlib import util    from taipy.gui import Gui  from taipy.gui.data.array_dict_data_accessor import _ArrayDictDataAccessor  from taipy.gui.data.data_format import _DataFormat  from taipy.gui.utils import _MapDict    an_array = [1, 2, 3]      def test_simple_data(gui: Gui, helpers):      accessor = _ArrayDictDataAccessor()      ret_data = accessor.get_data(gui, \"x\", an_array, {\"start\": 0, \"end\": -1}, _DataFormat.JSON)      assert ret_data      value = ret_data[\"value\"]      assert value      assert value[\"rowcount\"] == 3      data = value[\"data\"]      assert len(data) == 3      def test_simple_data_with_arrow(gui: Gui, helpers):      if util.find_spec(\"pyarrow\"):          accessor = _ArrayDictDataAccessor()          ret_data = accessor.get_data(gui, \"x\", an_array, {\"start\": 0, \"end\": -1}, _DataFormat.APACHE_ARROW)          assert ret_data          value = ret_data[\"value\"]          assert value          assert value[\"rowcount\"] == 3          data = value[\"data\"]          assert isinstance(data, bytes)      def test_slice(gui: Gui, helpers):      accessor = _ArrayDictDataAccessor()      value = accessor.get_data(gui, \"x\", an_array, {\"start\": 0, \"end\": 1}, _DataFormat.JSON)[\"value\"]      assert value[\"rowcount\"] == 3      data = value[\"data\"]      assert len(data) == 2      value = accessor.get_data(gui, \"x\", an_array, {\"start\": \"0\", \"end\": \"1\"}, _DataFormat.JSON)[\"value\"]      data = value[\"data\"]      assert len(data) == 2      def test_sort(gui: Gui, helpers):      accessor = _ArrayDictDataAccessor()      a_dict = {\"name\": [\"A\", \"B\", \"C\"], \"value\": [3, 2, 1]}      query = {\"columns\": [\"name\", \"value\"], \"start\": 0, \"end\": -1, \"orderby\": \"name\", \"sort\": \"desc\"}      data = accessor.get_data(gui, \"x\", a_dict, query, _DataFormat.JSON)[\"value\"][\"data\"]      assert data[0][\"name\"] == \"C\"      def test_aggregate(gui: Gui, helpers, small_dataframe):      accessor = _ArrayDictDataAccessor()      a_dict = {\"name\": [\"A\", \"B\", \"C\", \"A\"], \"value\": [3, 2, 1, 2]}      query = {\"columns\": [\"name\", \"value\"], \"start\": 0, \"end\": -1, \"aggregates\": [\"name\"], \"applies\": {\"value\": \"sum\"}}      value = accessor.get_data(gui, \"x\", a_dict, query, _DataFormat.JSON)[\"value\"]      assert value[\"rowcount\"] == 3      data = value[\"data\"]      agregValue = next(v.get(\"value\") for v in data if v.get(\"name\") == \"A\")      assert agregValue == 5      def test_array_of_array(gui: Gui, helpers, small_dataframe):      accessor = _ArrayDictDataAccessor()      an_array = [[1, 2, 3], [2, 4, 6]]      ret_data = accessor.get_data(gui, \"x\", an_array, {\"start\": 0, \"end\": -1}, _DataFormat.JSON)      assert ret_data      value = ret_data[\"value\"]      assert value      assert value[\"rowcount\"] == 2      data = value[\"data\"]      assert len(data) == 2      assert len(data[0]) == 4  # including _tp_index      def test_empty_array(gui: Gui, helpers, small_dataframe):      accessor = _ArrayDictDataAccessor()      an_array: list[str] = []      ret_data = accessor.get_data(gui, \"x\", an_array, {\"start\": 0, \"end\": -1}, _DataFormat.JSON)      assert ret_data      value = ret_data[\"value\"]      assert value      assert value[\"rowcount\"] == 0      data = value[\"data\"]      assert len(data) == 0      def test_array_of_diff_array(gui: Gui, helpers, small_dataframe):      accessor = _ArrayDictDataAccessor()      an_array = [[1, 2, 3], [2, 4]]      ret_data = accessor.get_data(gui, \"x\", an_array, {\"start\": 0, \"end\": -1, \"alldata\": True}, _DataFormat.JSON)      assert ret_data      value = ret_data[\"value\"]      assert value      assert value[\"multi\"] is True      data = value[\"data\"]      assert len(data) == 2      assert len(data[0][\"0/0\"]) == 3      assert len(data[1][\"1/0\"]) == 2      def test_array_of_dicts(gui: Gui, helpers, small_dataframe):      accessor = _ArrayDictDataAccessor()      an_array_of_dicts = [          {              \"temperatures\": [                  [17.2, 27.4, 28.6, 21.5],                  [5.6, 15.1, 20.2, 8.1],                  [26.6, 22.8, 21.8, 24.0],                  [22.3, 15.5, 13.4, 19.6],                  [3.9, 18.9, 25.7, 9.8],              ],              \"cities\": [\"Hanoi\", \"Paris\", \"Rio de Janeiro\", \"Sydney\", \"Washington\"],          },          {\"seasons\": [\"Winter\", \"Summer\", \"Spring\", \"Autumn\"]},      ]      ret_data = accessor.get_data(          gui, \"x\", an_array_of_dicts, {\"start\": 0, \"end\": -1, \"alldata\": True}, _DataFormat.JSON      )      assert ret_data      value = ret_data[\"value\"]      assert value      assert value[\"multi\"] is True      data = value[\"data\"]      assert len(data) == 2      assert len(data[0][\"temperatures\"]) == 5      assert len(data[1][\"seasons\"]) == 4      def test_array_of_Mapdicts(gui: Gui, helpers, small_dataframe):      accessor = _ArrayDictDataAccessor()      dict1 = _MapDict(          {              \"temperatures\": [                  [17.2, 27.4, 28.6, 21.5],                  [5.6, 15.1, 20.2, 8.1],                  [26.6, 22.8, 21.8, 24.0],                  [22.3, 15.5, 13.4, 19.6],                  [3.9, 18.9, 25.7, 9.8],              ],              \"cities\": [\"Hanoi\", \"Paris\", \"Rio de Janeiro\", \"Sydney\", \"Washington\"],          }      )      dict2 = _MapDict({\"seasons\": [\"Winter\", \"Summer\", \"Spring\", \"Autumn\"]})      ret_data = accessor.get_data(gui, \"x\", [dict1, dict2], {\"start\": 0, \"end\": -1, \"alldata\": True}, _DataFormat.JSON)      assert ret_data      value = ret_data[\"value\"]      assert value      assert value[\"multi\"] is True      data = value[\"data\"]      assert len(data) == 2      assert len(data[0][\"temperatures\"]) == 5      assert len(data[1][\"seasons\"]) == 4 "}
{"text": "import inspect    import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_slider_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      with tgb.Page(frame=None) as page:          tgb.slider(value=\"{x}\")      expected_list = [          \"<Slider\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0',          \"defaultValue={10}\",          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_slider_with_min_max_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 0)      with tgb.Page(frame=None) as page:          tgb.slider(value=\"{x}\", min=-10, max=10)      expected_list = [\"<Slider\", \"min={-10.0}\", \"max={10.0}\", \"defaultValue={0}\"]      helpers.test_control_builder(gui, page, expected_list)      def test_slider_with_dict_labels_builder(gui: Gui, helpers):      sel = \"Item 1\"  # noqa: F841      labels = {\"Item 1\": \"Label Start\", \"Item 3\": \"Label End\"}  # noqa: F841      gui._set_frame(inspect.currentframe())      with tgb.Page(frame=None) as page:          tgb.slider(value=\"{sel}\", lov=\"Item 1;Item 2;Item 3\", labels=labels)      expected_list = [          \"<Slider\",          'labels=\"{&quot;Item 1&quot;: &quot;Label Start&quot;, &quot;Item 3&quot;: &quot;Label End&quot;}\"',      ]      helpers.test_control_builder(gui, page, expected_list)      def test_slider_with_boolean_labels_builder(gui: Gui, helpers):      sel = \"Item 1\"  # noqa: F841      gui._set_frame(inspect.currentframe())      with tgb.Page(frame=None) as page:          tgb.slider(value=\"{sel}\", lov=\"Item 1;Item 2;Item 3\", labels=True)      expected_list = [\"<Slider\", \"labels={true}\"]      helpers.test_control_builder(gui, page, expected_list)      def test_slider_items_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"Item 1\")      with tgb.Page(frame=None) as page:          tgb.slider(value=\"{x}\", lov=\"Item 1;Item 2;Item 3\", text_anchor=\"left\")      expected_list = [          \"<Slider\",          'updateVarName=\"_TpLv_tpec_TpExPr_x_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_x_TPMDL_0}\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'textAnchor=\"left\"',      ]      helpers.test_control_builder(gui, page, expected_list)      def test_slider_text_anchor_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"Item 1\")      with tgb.Page(frame=None) as page:          tgb.slider(value=\"{x}\", text_anchor=None)      expected_list = [          \"<Slider\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",          'textAnchor=\"none\"',      ]      helpers.test_control_builder(gui, page, expected_list)      def test_slider_text_anchor_default_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"Item 1\")      with tgb.Page(frame=None) as page:          tgb.slider(value=\"{x}\", items=\"Item 1\")      expected_list = [          \"<Slider\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",          'textAnchor=\"bottom\"',      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_button_builder_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"name\", \"World!\")      gui._bind_var_val(\"btn_id\", \"button1\")      with tgb.Page(frame=None) as page:          tgb.button(label=\"Hello {name}\", id=\"{btn_id}\")      expected_list = [\"<Button\", 'defaultLabel=\"Hello World!\"', \"label={tp_TpExPr_Hello_name_TPMDL_0_0\"]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_selector_builder_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"selected_val\", [\"l1\", \"l2\"])      gui._bind_var_val(\"selector_properties\", {\"lov\": [(\"l1\", \"v1\"), (\"l2\", \"v2\"), (\"l3\", \"v3\")], \"filter\": True})      with tgb.Page(frame=None) as page:          tgb.selector(value=\"{selected_val}\", properties=\"{selector_properties}\", multiple=True)      expected_list = [          \"<Selector\",          'defaultLov=\"[[&quot;l1&quot;, &quot;v1&quot;], [&quot;l2&quot;, &quot;v2&quot;], [&quot;l3&quot;, &quot;v3&quot;]]\"',          'defaultValue=\"[&quot;l1&quot;, &quot;l2&quot;]\"',          \"filter={true}\",          \"multiple={true}\",          'updateVarName=\"_TpLv_tpec_TpExPr_selected_val_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_val_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_selector_builder_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"selected_val\", \"Item 2\")      with tgb.Page(frame=None) as page:          tgb.selector(value=\"{selected_val}\", lov=\"Item 1;Item 2; This is a another value\")      expected_list = [          \"<Selector\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot; This is a another value&quot;]\"',          'defaultValue=\"[&quot;Item 2&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_selected_val_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_val_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_selector_builder_3(gui: Gui, test_client, helpers):      gui._bind_var_val(\"elt\", None)      gui._bind_var_val(          \"scenario_list\",          [{\"id\": \"1\", \"name\": \"scenario 1\"}, {\"id\": \"3\", \"name\": \"scenario 3\"}, {\"id\": \"2\", \"name\": \"scenario 2\"}],      )      gui._bind_var_val(\"selected_obj\", {\"id\": \"1\", \"name\": \"scenario 1\"})      with tgb.Page(frame=None) as page:          tgb.selector(              value=\"{selected_obj}\",              lov=\"{scenario_list}\",              adapter=\"{lambda elt: (elt['id'], elt['name'])}\",              propagate=False,          )      expected_list = [          \"<Selector\",          'defaultLov=\"[[&quot;1&quot;, &quot;scenario 1&quot;], [&quot;3&quot;, &quot;scenario 3&quot;], [&quot;2&quot;, &quot;scenario 2&quot;]]\"',          'defaultValue=\"[&quot;1&quot;]\"',          \"lov={_TpL_tpec_TpExPr_scenario_list_TPMDL_0}\",          \"propagate={false}\",          'updateVars=\"lov=_TpL_tpec_TpExPr_scenario_list_TPMDL_0\"',          'updateVarName=\"_TpLv_tpec_TpExPr_selected_obj_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_obj_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import inspect    import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_input_builder(gui: Gui, helpers):      x = \"Hello World!\"  # noqa: F841      gui._set_frame(inspect.currentframe())      with tgb.Page(frame=None) as page:          tgb.input(value=\"{x}\")      expected_list = [          \"<Input\",          'updateVarName=\"tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"Hello World!\"',          'type=\"text\"',          \"value={tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_password_builder(gui: Gui, helpers):      x = \"Hello World!\"  # noqa: F841      gui._set_frame(inspect.currentframe())      with tgb.Page(frame=None) as page:          tgb.input(value=\"{x}\", password=True)      expected_list = [          \"<Input\",          'updateVarName=\"tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"Hello World!\"',          'type=\"password\"',          \"value={tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_tree_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"value\", \"Item 1\")      with tgb.Page(frame=None) as page:          tgb.tree(value=\"{value}\", lov=\"Item 1;Item 2;Item 3\")      expected_list = [          \"<TreeView\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_value_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_value_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_tree_expanded_builder_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"value\", \"Item 1\")      with tgb.Page(frame=None) as page:          tgb.tree(value=\"{value}\", lov=\"Item 1;Item 2;Item 3\", expanded=False)      expected_list = [          \"<TreeView\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_value_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_value_TPMDL_0}\",          \"expanded={false}\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_tree_expanded_builder_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"value\", \"Item 1\")      gui._bind_var_val(\"expa\", [\"Item1\"])      with tgb.Page(frame=None) as page:          tgb.tree(value=\"{value}\", lov=\"Item 1;Item 2;Item 3\", expanded=\"{expa}\")      expected_list = [          \"<TreeView\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_value_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_value_TPMDL_0}\",          'defaultExpanded=\"[&quot;Item1&quot;]\"',          \"expanded={tpec_TpExPr_expa_TPMDL_0}\",          'updateVars=\"expanded=tpec_TpExPr_expa_TPMDL_0',      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_expandable_builder_1(gui: Gui, helpers):      with tgb.expandable(title=\"Expandable section\", expanded=False) as content:          tgb.text(value=\"This is an expandable section\")      expected_list = [          \"<Expandable\",          \"expanded={false}\",          'title=\"Expandable section\"',          \"This is an expandable section\",      ]      helpers.test_control_builder(gui, tgb.Page(content, frame=None), expected_list) "}
{"text": "import inspect    import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_table_builder_1(gui: Gui, helpers, csvdata):      with tgb.Page(frame=None) as page:          tgb.table(              data=\"{csvdata}\",              page_size=10,              page_size_options=[10, 30, 100],              columns=[\"Day\", \"Entity\", \"Code\", \"Daily hospital occupancy\"],              date_format=\"eee dd MMM yyyy\",          )      expected_list = [          \"<Table\",          'defaultColumns=\"{&quot;Entity&quot;: &#x7B;&quot;index&quot;: 1, &quot;type&quot;: &quot;object&quot;, &quot;dfid&quot;: &quot;Entity&quot;&#x7D;, &quot;Code&quot;: &#x7B;&quot;index&quot;: 2, &quot;type&quot;: &quot;object&quot;, &quot;dfid&quot;: &quot;Code&quot;&#x7D;, &quot;Daily hospital occupancy&quot;: &#x7B;&quot;index&quot;: 3, &quot;type&quot;: &quot;int&quot;, &quot;dfid&quot;: &quot;Daily hospital occupancy&quot;&#x7D;, &quot;Day_str&quot;: &#x7B;&quot;index&quot;: 0, &quot;type&quot;: &quot;datetime&quot;, &quot;dfid&quot;: &quot;Day&quot;, &quot;format&quot;: &quot;eee dd MMM yyyy&quot;&#x7D;}\"',          'height=\"80vh\"',          'width=\"100%\"',          'pageSizeOptions=\"[10, 30, 100]\"',          \"pageSize={10.0}\",          \"selected={[]}\",          'updateVarName=\"_TpD_tpec_TpExPr_csvdata_TPMDL_0\"',          \"data={_TpD_tpec_TpExPr_csvdata_TPMDL_0}\",      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_builder(gui, page, expected_list)      def test_table_reset_builder(gui: Gui, helpers, csvdata):      with tgb.Page(frame=None) as page:          tgb.table(              data=\"{csvdata}\",              rebuild=True,              page_size=10,              page_size_options=\"10;30;100\",              columns=\"Day;Entity;Code;Daily hospital occupancy\",              date_format=\"eee dd MMM yyyy\",          )      expected_list = [          \"<Table\",          'defaultColumns=\"{&quot;Entity&quot;: &#x7B;&quot;index&quot;: 1, &quot;type&quot;: &quot;object&quot;, &quot;dfid&quot;: &quot;Entity&quot;&#x7D;, &quot;Code&quot;: &#x7B;&quot;index&quot;: 2, &quot;type&quot;: &quot;object&quot;, &quot;dfid&quot;: &quot;Code&quot;&#x7D;, &quot;Daily hospital occupancy&quot;: &#x7B;&quot;index&quot;: 3, &quot;type&quot;: &quot;int&quot;, &quot;dfid&quot;: &quot;Daily hospital occupancy&quot;&#x7D;, &quot;Day_str&quot;: &#x7B;&quot;index&quot;: 0, &quot;type&quot;: &quot;datetime&quot;, &quot;dfid&quot;: &quot;Day&quot;, &quot;format&quot;: &quot;eee dd MMM yyyy&quot;&#x7D;}\"',          'height=\"80vh\"',          'width=\"100%\"',          'pageSizeOptions=\"[10, 30, 100]\"',          \"pageSize={10.0}\",          \"selected={[]}\",          'updateVarName=\"_TpD_tpec_TpExPr_csvdata_TPMDL_0\"',          \"data={_TpD_tpec_TpExPr_csvdata_TPMDL_0}\",          \"columns={tp_TpExPr_gui_tbl_cols_True_None_7B_22columns_22_3A_20_22Day_3BEntity_3BCode_3BDaily_20hospital_20occupancy_22_2C_20_22date_format_22_3A_20_22eee_20dd_20MMM_20yyyy_22_7D_7B_22data_22_3A_20_22tpec_TpExPr_csvdata_TPMDL_0_22_7D_tpec_TpExPr_csvdata_TPMDL_0_csvdata_TPMDL_0_0}\",      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_builder(gui, page, expected_list)      def test_table_builder_2(gui: Gui, helpers, csvdata):      table_properties = {  # noqa: F841          \"page_size\": 10,          \"page_size_options\": [10, 50, 100, 500],          \"allow_all_rows\": True,          \"columns\": {              \"Day\": {\"index\": 0, \"format\": \"dd/MM/yyyy\", \"title\": \"Date of measure\"},              \"Entity\": {\"index\": 1},              \"Code\": {\"index\": 2},              \"Daily hospital occupancy\": {\"index\": 3},          },          \"date_format\": \"eee dd MMM yyyy\",          \"number_format\": \"%.3f\",          \"width\": \"60vw\",          \"height\": \"60vh\",      }      with tgb.Page(frame=None) as page:          tgb.table(data=\"{csvdata}\", properties=\"table_properties\", auto_loading=True, editable=False)      expected_list = [          \"<Table\",          \"allowAllRows={true}\",          \"autoLoading={true}\",          \"editable={false}\",          'defaultColumns=\"{&quot;Entity&quot;: &#x7B;&quot;index&quot;: 1, &quot;type&quot;: &quot;object&quot;, &quot;dfid&quot;: &quot;Entity&quot;&#x7D;, &quot;Code&quot;: &#x7B;&quot;index&quot;: 2, &quot;type&quot;: &quot;object&quot;, &quot;dfid&quot;: &quot;Code&quot;&#x7D;, &quot;Daily hospital occupancy&quot;: &#x7B;&quot;index&quot;: 3, &quot;type&quot;: &quot;int&quot;, &quot;dfid&quot;: &quot;Daily hospital occupancy&quot;, &quot;format&quot;: &quot;%.3f&quot;&#x7D;, &quot;Day_str&quot;: &#x7B;&quot;index&quot;: 0, &quot;format&quot;: &quot;dd/MM/yyyy&quot;, &quot;title&quot;: &quot;Date of measure&quot;, &quot;type&quot;: &quot;datetime&quot;, &quot;dfid&quot;: &quot;Day&quot;&#x7D;}\"',          'height=\"60vh\"',          'width=\"60vw\"',          'pageSizeOptions=\"[10, 50, 100, 500]\"',          \"pageSize={10}\",          \"selected={[]}\",          'updateVarName=\"_TpD_tpec_TpExPr_csvdata_TPMDL_0\"',          \"data={_TpD_tpec_TpExPr_csvdata_TPMDL_0}\",      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import os  import pathlib  from importlib import util    import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_image_url_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", \"some_url\")      with tgb.Page(frame=None) as page:          tgb.image(content=\"{content}\")      expected_list = [          \"<Image\",          \"content={_TpCi_tpec_TpExPr_content_TPMDL_0}\",          'defaultContent=\"some_url\"',      ]      helpers.test_control_builder(gui, page, expected_list)      def test_image_file_builder(gui: Gui, test_client, helpers):      with open((pathlib.Path(__file__).parent.parent.parent / \"resources\" / \"fred.png\").resolve(), \"rb\") as content:          gui._bind_var_val(\"content\", content.read())          with tgb.Page(frame=None) as page:              tgb.image(content=\"{content}\")          expected_list = [              \"<Image\",              'defaultContent=\"data:image/png;base64,',          ]          if not util.find_spec(\"magic\"):              expected_list = [\"<Image\", 'defaultContent=\"/taipy-content/taipyStatic0/TaiPyContent.', \".bin\"]          helpers.test_control_builder(gui, page, expected_list)      def test_image_path_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"content\", str((pathlib.Path(__file__).parent.parent.parent / \"resources\" / \"fred.png\").resolve())      )      with tgb.Page(frame=None) as page:          tgb.image(content=\"{content}\")      expected_list = [          \"<Image\",          'defaultContent=\"/taipy-content/taipyStatic0/fred.png',      ]      helpers.test_control_builder(gui, page, expected_list)      def test_image_bad_file_builder(gui: Gui, test_client, helpers):      with open(os.path.abspath(__file__), \"rb\") as content:          gui._bind_var_val(\"content\", content.read())          with tgb.Page(frame=None) as page:              tgb.image(content=\"{content}\")          expected_list = [              \"<Image\",              'defaultContent=\"Invalid content: text/x',          ]          if not util.find_spec(\"magic\"):              expected_list = [\"<Image\", 'defaultContent=\"/taipy-content/taipyStatic0/TaiPyContent.', \".bin\"]          helpers.test_control_builder(gui, page, expected_list) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_html_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"name\", \"World!\")      gui._bind_var_val(\"btn_id\", \"button1\")      with tgb.Page(frame=None) as page:          tgb.html(\"h1\", \"This is a header\", style=\"color:Tomato;\")          with tgb.html(\"p\", \"This is a paragraph.\", style=\"color:green;\"):              tgb.html(\"a\", \"a text\", href=\"https://www.w3schools.com\", target=\"_blank\")              tgb.html(\"br\")              tgb.html(\"b\", \"This is bold text inside the paragrah.\")      expected_list = [          '<h1 style=\"color:Tomato;\">This is a header',          '<p style=\"color:green;\">This is a paragraph.',          '<a href=\"https://www.w3schools.com\" target=\"_blank\">a text',          \"<br>\",          \"<b>This is bold text inside the paragrah.\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import inspect    import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_status_builder(gui: Gui, helpers):      status = [{\"status\": \"info\", \"message\": \"Info Message\"}]  # noqa: F841      with tgb.Page(frame=None) as page:          tgb.status(value=\"{status}\")      expected_list = [          \"<Status\",          'defaultValue=\"[&#x7B;&quot;status&quot;: &quot;info&quot;, &quot;message&quot;: &quot;Info Message&quot;&#x7D;]\"',          \"value={tpec_TpExPr_status_TPMDL_0}\",      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_toggle_builder(gui: Gui, helpers):      with tgb.Page(frame=None) as page:          tgb.toggle(theme=True)      expected_list = [\"<Toggle\", 'kind=\"theme\"', 'unselectedValue=\"\"']      helpers.test_control_builder(gui, page, expected_list)      def test_toggle_allow_unselected_builder(gui: Gui, helpers):      with tgb.Page(frame=None) as page:          tgb.toggle(allow_unselect=True, lov=\"1;2\")      expected_list = [\"<Toggle\", 'unselectedValue=\"\"', \"allowUnselect={true}\"]      helpers.test_control_builder(gui, page, expected_list)      def test_toggle_lov_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"l1\")      gui._bind_var_val(\"lov\", [(\"l1\", \"v1\"), (\"l2\", \"v2\")])      with tgb.Page(frame=None) as page:          tgb.toggle(lov=\"{lov}\", value=\"{x}\", label=\"Label\")      expected_list = [          \"<Toggle\",          'defaultLov=\"[[&quot;l1&quot;, &quot;v1&quot;], [&quot;l2&quot;, &quot;v2&quot;]]\"',          'defaultValue=\"l1\"',          'label=\"Label\"',          \"lov={_TpL_tpec_TpExPr_lov_TPMDL_0}\",          'updateVars=\"lov=_TpL_tpec_TpExPr_lov_TPMDL_0\"',          'updateVarName=\"_TpLv_tpec_TpExPr_x_TPMDL_0\"',          'unselectedValue=\"\"',          \"value={_TpLv_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_pane_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"show_pane\", False)      with tgb.Page(frame=None) as page:          with tgb.pane(open=\"{show_pane}\"):              tgb.text(value=\"This is a Pane\")      expected_list = [          \"<Pane\",          'anchor=\"left\"',          'updateVarName=\"_TpB_tpec_TpExPr_show_pane_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_show_pane_TPMDL_0}\",          \"This is a Pane\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_pane_persistent_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"show_pane\", False)      with tgb.Page(frame=None) as page:          with tgb.pane(open=\"{show_pane}\", persistent=True):              tgb.text(value=\"This is a Pane\")      expected_list = [          \"<Pane\",          'anchor=\"left\"',          \"persistent={true}\",          'updateVarName=\"_TpB_tpec_TpExPr_show_pane_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_show_pane_TPMDL_0}\",          \"This is a Pane\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_text_builder_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      with tgb.Page(frame=None) as page:          tgb.text(value=\"{x}\")      expected_list = [\"<Field\", 'dataType=\"int\"', 'defaultValue=\"10\"', \"value={tpec_TpExPr_x_TPMDL_0}\"]      helpers.test_control_builder(gui, page, expected_list)      def test_text_builder_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      with tgb.Page(frame=None) as page:          tgb.text(\"{x}\")      expected_list = [\"<Field\", 'dataType=\"int\"', 'defaultValue=\"10\"', \"value={tpec_TpExPr_x_TPMDL_0}\"]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import os  import pathlib  from importlib import util    import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_file_download_url_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", \"some_url\")      with tgb.Page(frame=None) as page:          tgb.file_download(content=\"{content}\")      expected_list = [          \"<FileDownload\",          \"content={_TpC_tpec_TpExPr_content_TPMDL_0}\",          'defaultContent=\"some_url\"',      ]      helpers.test_control_builder(gui, page, expected_list)      def test_file_download_file_builder(gui: Gui, test_client, helpers):      with open((pathlib.Path(__file__).parent.parent.parent / \"resources\" / \"fred.png\").resolve(), \"rb\") as content:          gui._bind_var_val(\"content\", content.read())          with tgb.Page(frame=None) as page:              tgb.file_download(content=\"{content}\")          expected_list = [              \"<FileDownload\",              'defaultContent=\"data:image/png;base64,',          ]          if not util.find_spec(\"magic\"):              expected_list = [\"<FileDownload\", 'defaultContent=\"/taipy-content/taipyStatic0/TaiPyContent.', \".bin\"]          helpers.test_control_builder(gui, page, expected_list)      def test_file_download_path_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"content\", str((pathlib.Path(__file__).parent.parent.parent / \"resources\" / \"fred.png\").resolve())      )      with tgb.Page(frame=None) as page:          tgb.file_download(content=\"{content}\")      expected_list = [          \"<FileDownload\",          'defaultContent=\"/taipy-content/taipyStatic0/fred.png',      ]      helpers.test_control_builder(gui, page, expected_list)      def test_file_download_any_file_builder(gui: Gui, test_client, helpers):      with open(os.path.abspath(__file__), \"rb\") as content:          gui._bind_var_val(\"content\", content.read())          with tgb.Page(frame=None) as page:              tgb.file_download(content=\"{content}\")          expected_list = [              \"<FileDownload\",              'defaultContent=\"data:text/x',              \"python;base64,\",          ]          if not util.find_spec(\"magic\"):              expected_list = [\"<FileDownload\", 'defaultContent=\"/taipy-content/taipyStatic0/TaiPyContent.', \".bin\"]          helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_file_selector_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", None)      with tgb.Page(frame=None) as page:          tgb.file_selector(content=\"{content}\", label=\"label\", on_action=\"action\")      expected_list = [          \"<FileSelector\",          'updateVarName=\"tpec_TpExPr_content_TPMDL_0\"',          'label=\"label\"',          'onAction=\"action\"',      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import inspect    import taipy.gui.builder as tgb  from taipy.gui import Gui, Markdown      def test_dialog_builder_1(gui: Gui, helpers):      dialog_open = False  # noqa: F841      gui._set_frame(inspect.currentframe())      with tgb.Page(frame=None) as page:          tgb.dialog(title=\"This is a Dialog\", open=\"{dialog_open}\", page=\"page_test\", on_action=\"validate_action\")      expected_list = [          \"<Dialog\",          'onAction=\"validate_action\"',          'page=\"page_test\"',          'title=\"This is a Dialog\"',          'updateVarName=\"_TpB_tpec_TpExPr_dialog_open_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_dialog_open_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_dialog_builder_2(gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      partial = gui.add_partial(Markdown(\"# A partial\"))  # noqa: F841      dialog_open = False  # noqa: F841      with tgb.Page(frame=None) as page:          tgb.dialog(              title=\"Another Dialog\",              open=\"{dialog_open}\",              partial=\"{partial}\",              on_action=\"validate_action\",          )      expected_list = [          \"<Dialog\",          'page=\"TaiPy_partials',          'title=\"Another Dialog\"',          'onAction=\"validate_action\"',          'updateVarName=\"_TpB_tpec_TpExPr_dialog_open_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_dialog_open_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_dialog_labels_builder(gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      dialog_open = False  # noqa: F841      with tgb.Page(frame=None) as page:          tgb.dialog(              title=\"Another Dialog\",              open=\"{dialog_open}\",              page=\"page_test\",              labels=[\"Cancel\", \"Validate\"],              close_label=\"MYClose\",          )      expected_list = [          \"<Dialog\",          'page=\"page_test\"',          'title=\"Another Dialog\"',          'labels=\"[&quot;Cancel&quot;, &quot;Validate&quot;]\"',          'updateVarName=\"_TpB_tpec_TpExPr_dialog_open_TPMDL_0\"',          'closeLabel=\"MYClose\"',          \"open={_TpB_tpec_TpExPr_dialog_open_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_menu_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"lov\", [\"Item 1\", \"Item 2\", \"Item 3\", \"Item 4\"])      with tgb.Page(frame=None) as page:          tgb.menu(lov=\"{lov}\", on_action=\"on_menu_action\")      expected_list = [          \"<MenuCtl\",          'libClassName=\"taipy-menu\"',          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;, &quot;Item 4&quot;]\"',          \"lov={_TpL_tpec_TpExPr_lov_TPMDL_0}\",          'onAction=\"on_menu_action\"',          'updateVars=\"lov=_TpL_tpec_TpExPr_lov_TPMDL_0\"',      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_layout_builder_1(gui: Gui, helpers):      with tgb.Page(frame=None) as page:          with tgb.layout(columns=\"1 1\", gap=\"1rem\"):              tgb.text(value=\"This is a layout section\")      expected_list = [\"<Layout\", 'columns=\"1 1', 'gap=\"1rem\"', \"This is a layout section\"]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_number_builder_1(gui: Gui, helpers):      with tgb.Page(frame=None) as page:          tgb.number(value=\"10\")      expected_list = [\"<Input\", 'value=\"10\"', 'type=\"number\"']      helpers.test_control_builder(gui, page, expected_list)      def test_number_builder_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"10\")      with tgb.Page(frame=None) as page:          tgb.number(value=\"{x}\")      expected_list = [          \"<Input\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"10\"',          'type=\"number\"',          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "from datetime import datetime    import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_date_builder_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"date\", datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"))      with tgb.Page(frame=None) as page:          tgb.date(id=\"date\", date=\"{date}\")      expected_list = [          \"<DateSelector\",          'defaultDate=\"2020-12-',          'updateVarName=\"_TpDt_tpec_TpExPr_date_TPMDL_0\"',          \"date={_TpDt_tpec_TpExPr_date_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_date_builder_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"date\", datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"))      with tgb.Page(frame=None) as page:          tgb.date(id=\"date\", date=\"{date}\", with_time=True)      expected_list = [          \"<DateSelector\",          'defaultDate=\"2020-12-',          'updateVarName=\"_TpDt_tpec_TpExPr_date_TPMDL_0\"',          \"date={_TpDt_tpec_TpExPr_date_TPMDL_0}\",          \"withTime={true}\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_indicator_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(\"val\", 15)      with tgb.Page(frame=None) as page:          tgb.indicator(display=12, value=\"{val}\", min=1, max=20, format=\"%.2f\")      expected_list = [          \"<Indicator\",          'libClassName=\"taipy-indicator\"',          \"defaultValue={15}\",          \"display={12.0}\",          'format=\"%.2f\"',          \"max={20.0}\",          \"min={1.0}\",          \"value={_TpN_tpec_TpExPr_val_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_navbar_builder(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"navlov\",          [              (\"/page1\", \"Page 1\"),              (\"/page2\", \"Page 2\"),              (\"/page3\", \"Page 3\"),              (\"/page4\", \"Page 4\"),          ],      )      with tgb.Page(frame=None) as page:          tgb.navbar(lov=\"{navlov}\")      expected_list = [          \"<NavBar\",          'defaultLov=\"[[&quot;/page1&quot;, &quot;Page 1&quot;], [&quot;/page2&quot;, &quot;Page 2&quot;], [&quot;/page3&quot;, &quot;Page 3&quot;], [&quot;/page4&quot;, &quot;Page 4&quot;]]\"',          \"lov={_TpL_tpec_TpExPr_navlov_TPMDL_0}\",      ]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_part_builder_1(gui: Gui, helpers):      with tgb.Page(frame=None) as page:          with tgb.part(class_name=\"class1\"):              tgb.text(value=\"This is a part\")      expected_list = [\"<Part\", \"This is a part\"]      helpers.test_control_builder(gui, page, expected_list) "}
{"text": "import inspect    from taipy.gui import Gui      def test_slider_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      md_string = \"<|{x}|slider|>\"      expected_list = [          \"<Slider\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0',          \"defaultValue={10}\",          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_slider_with_min_max(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 0)      md_string = \"<|{x}|slider|min=-10|max=10|>\"      expected_list = [\"<Slider\", \"min={-10.0}\", \"max={10.0}\", \"defaultValue={0}\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_slider_with_dict_labels_md(gui: Gui, helpers):      sel = \"Item 1\"  # noqa: F841      labels = {\"Item 1\": \"Label Start\", \"Item 3\": \"Label End\"}  # noqa: F841      gui._set_frame(inspect.currentframe())      md_string = \"<|{sel}|slider|lov=Item 1;Item 2;Item 3|labels={labels}|>\"      expected_list = [          \"<Slider\",          'labels=\"{&quot;Item 1&quot;: &quot;Label Start&quot;, &quot;Item 3&quot;: &quot;Label End&quot;}\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_slider_with_boolean_labels_md(gui: Gui, helpers):      sel = \"Item 1\"  # noqa: F841      gui._set_frame(inspect.currentframe())      md_string = \"<|{sel}|slider|lov=Item 1;Item 2;Item 3|labels|>\"      expected_list = [\"<Slider\", \"labels={true}\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_slider_items_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"Item 1\")      md_string = \"<|{x}|slider|lov=Item 1;Item 2;Item 3|text_anchor=left|>\"      expected_list = [          \"<Slider\",          'updateVarName=\"_TpLv_tpec_TpExPr_x_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_x_TPMDL_0}\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'textAnchor=\"left\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_slider_text_anchor_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"Item 1\")      md_string = \"<|{x}|slider|text_anchor=NoNe|>\"      expected_list = [          \"<Slider\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",          'textAnchor=\"none\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_slider_text_anchor_default_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"Item 1\")      md_string = \"<|{x}|slider|items=Item 1|>\"      expected_list = [          \"<Slider\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",          'textAnchor=\"bottom\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_slider_array_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", [10, 20])      md_string = \"<|{x}|slider|>\"      expected_list = [          \"<Slider\",          'updateVarName=\"_TpLn_tpec_TpExPr_x_TPMDL_0\"',          \"value={_TpLn_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_slider_html_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      html_string = '<taipy:slider value=\"{x}\" />'      expected_list = [          \"<Slider\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          \"defaultValue={10}\",          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_slider_html_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      html_string = \"<taipy:slider>{x}</taipy:slider>\"      expected_list = [          \"<Slider\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          \"defaultValue={10}\",          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from taipy.gui import Gui      def test_button_md_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"name\", \"World!\")      gui._bind_var_val(\"btn_id\", \"button1\")      md_string = \"<|Hello {name}|button|id={btn_id}|>\"      expected_list = [\"<Button\", 'defaultLabel=\"Hello World!\"', \"label={tp_TpExPr_Hello_name_TPMDL_0_0\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_button_md_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"name\", \"World!\")      gui._bind_var_val(\"btn_id\", \"button1\")      md_string = \"<|button|label=Hello {name}|id={btn_id}|>\"      expected_list = [\"<Button\", 'defaultLabel=\"Hello World!\"', \"label={tp_TpExPr_Hello_name_TPMDL_0_0\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_button_html_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"name\", \"World!\")      gui._bind_var_val(\"btn_id\", \"button1\")      html_string = '<taipy:button label=\"Hello {name}\" id=\"{btn_id}\" />'      expected_list = [\"<Button\", 'defaultLabel=\"Hello World!\"', \"label={tp_TpExPr_Hello_name_TPMDL_0_0\"]      helpers.test_control_html(gui, html_string, expected_list)      def test_button_html_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"name\", \"World!\")      gui._bind_var_val(\"btn_id\", \"button1\")      html_string = '<taipy:button id=\"{btn_id}\">Hello {name}</taipy:button>'      expected_list = [\"<Button\", 'defaultLabel=\"Hello World!\"', \"label={tp_TpExPr_Hello_name_TPMDL_0_0\"]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_selector_md_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"selected_val\", [\"l1\", \"l2\"])      gui._bind_var_val(\"selector_properties\", {\"lov\": [(\"l1\", \"v1\"), (\"l2\", \"v2\"), (\"l3\", \"v3\")], \"filter\": True})      md_string = \"<|{selected_val}|selector|properties=selector_properties|multiple|>\"      expected_list = [          \"<Selector\",          'defaultLov=\"[[&quot;l1&quot;, &quot;v1&quot;], [&quot;l2&quot;, &quot;v2&quot;], [&quot;l3&quot;, &quot;v3&quot;]]\"',          'defaultValue=\"[&quot;l1&quot;, &quot;l2&quot;]\"',          \"filter={true}\",          \"multiple={true}\",          'updateVarName=\"_TpLv_tpec_TpExPr_selected_val_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_val_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_selector_md_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"selected_val\", \"Item 2\")      md_string = \"<|{selected_val}|selector|lov=Item 1;Item 2; This is a another value|>\"      expected_list = [          \"<Selector\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot; This is a another value&quot;]\"',          'defaultValue=\"[&quot;Item 2&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_selected_val_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_val_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_selector_md_3(gui: Gui, test_client, helpers):      gui._bind_var_val(\"elt\", None)      gui._bind_var_val(          \"scenario_list\",          [{\"id\": \"1\", \"name\": \"scenario 1\"}, {\"id\": \"3\", \"name\": \"scenario 3\"}, {\"id\": \"2\", \"name\": \"scenario 2\"}],      )      gui._bind_var_val(\"selected_obj\", {\"id\": \"1\", \"name\": \"scenario 1\"})      md_string = '<|{selected_obj}|selector|lov={scenario_list}|type=Scenario|adapter={lambda elt: (elt[\"id\"], elt[\"name\"])}|not propagate|>'      expected_list = [          \"<Selector\",          'defaultLov=\"[[&quot;1&quot;, &quot;scenario 1&quot;], [&quot;3&quot;, &quot;scenario 3&quot;], [&quot;2&quot;, &quot;scenario 2&quot;]]\"',          'defaultValue=\"[&quot;1&quot;]\"',          \"lov={_TpL_tpec_TpExPr_scenario_list_TPMDL_0}\",          \"propagate={false}\",          'updateVars=\"lov=_TpL_tpec_TpExPr_scenario_list_TPMDL_0\"',          'updateVarName=\"_TpLv_tpec_TpExPr_selected_obj_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_obj_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_selector_html_1_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"selected_val\", [\"l1\", \"l2\"])      gui._bind_var_val(\"selector_properties\", {\"lov\": [(\"l1\", \"v1\"), (\"l2\", \"v2\"), (\"l3\", \"v3\")], \"filter\": True})      html_string = '<taipy:selector value=\"{selected_val}\" properties=\"selector_properties\" multiple=\"True\"/>'      expected_list = [          \"<Selector\",          'defaultLov=\"[[&quot;l1&quot;, &quot;v1&quot;], [&quot;l2&quot;, &quot;v2&quot;], [&quot;l3&quot;, &quot;v3&quot;]]\"',          'defaultValue=\"[&quot;l1&quot;, &quot;l2&quot;]\"',          \"filter={true}\",          \"multiple={true}\",          'updateVarName=\"_TpLv_tpec_TpExPr_selected_val_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_val_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_selector_html_1_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"selected_val\", [\"l1\", \"l2\"])      gui._bind_var_val(\"selector_properties\", {\"lov\": [(\"l1\", \"v1\"), (\"l2\", \"v2\"), (\"l3\", \"v3\")], \"filter\": True})      html_string = '<taipy:selector properties=\"selector_properties\" multiple=\"True\">{selected_val}</taipy:selector>'      expected_list = [          \"<Selector\",          'defaultLov=\"[[&quot;l1&quot;, &quot;v1&quot;], [&quot;l2&quot;, &quot;v2&quot;], [&quot;l3&quot;, &quot;v3&quot;]]\"',          'defaultValue=\"[&quot;l1&quot;, &quot;l2&quot;]\"',          \"filter={true}\",          \"multiple={true}\",          'updateVarName=\"_TpLv_tpec_TpExPr_selected_val_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_val_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_selector_html_2_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"selected_val\", \"Item 2\")      html_string = '<taipy:selector value=\"{selected_val}\" lov=\"Item 1;Item 2; This is a another value\" />'      expected_list = [          \"<Selector\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot; This is a another value&quot;]\"',          'defaultValue=\"[&quot;Item 2&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_selected_val_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_val_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_selector_html_2_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"selected_val\", \"Item 2\")      html_string = '<taipy:selector lov=\"Item 1;Item 2; This is a another value\">{selected_val}</taipy:selector>'      expected_list = [          \"<Selector\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot; This is a another value&quot;]\"',          'defaultValue=\"[&quot;Item 2&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_selected_val_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_selected_val_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "import inspect    from taipy.gui import Gui      def test_input_md(gui: Gui, helpers):      x = \"Hello World!\"  # noqa: F841      gui._set_frame(inspect.currentframe())      md_string = \"<|{x}|input|>\"      expected_list = [          \"<Input\",          'updateVarName=\"tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"Hello World!\"',          'type=\"text\"',          \"value={tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_password_md(gui: Gui, helpers):      x = \"Hello World!\"  # noqa: F841      gui._set_frame(inspect.currentframe())      md_string = \"<|{x}|input|password|>\"      expected_list = [          \"<Input\",          'updateVarName=\"tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"Hello World!\"',          'type=\"password\"',          \"value={tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_input_html_1(gui: Gui, helpers):      x = \"Hello World!\"  # noqa: F841      gui._set_frame(inspect.currentframe())      html_string = '<taipy:input value=\"{x}\" />'      expected_list = [          \"<Input\",          'updateVarName=\"tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"Hello World!\"',          'type=\"text\"',          \"value={tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_password_html(gui: Gui, helpers):      x = \"Hello World!\"  # noqa: F841      gui._set_frame(inspect.currentframe())      html_string = '<taipy:input value=\"{x}\" password=\"True\" />'      expected_list = [          \"<Input\",          'updateVarName=\"tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"Hello World!\"',          'type=\"password\"',          \"value={tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_input_html_2(gui: Gui, helpers):      x = \"Hello World!\"  # noqa: F841      gui._set_frame(inspect.currentframe())      html_string = \"<taipy:input>{x}</taipy:input>\"      expected_list = [          \"<Input\",          'updateVarName=\"tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"Hello World!\"',          'type=\"text\"',          \"value={tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_tree_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"value\", \"Item 1\")      md_string = \"<|{value}|tree|lov=Item 1;Item 2;Item 3|>\"      expected_list = [          \"<TreeView\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_value_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_value_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_tree_expanded_md_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"value\", \"Item 1\")      md_string = \"<|{value}|tree|lov=Item 1;Item 2;Item 3|not expanded|>\"      expected_list = [          \"<TreeView\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_value_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_value_TPMDL_0}\",          \"expanded={false}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_tree_expanded_md_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"value\", \"Item 1\")      gui._bind_var_val(\"expa\", [\"Item1\"])      md_string = \"<|{value}|tree|lov=Item 1;Item 2;Item 3|expanded={expa}|>\"      expected_list = [          \"<TreeView\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_value_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_value_TPMDL_0}\",          'defaultExpanded=\"[&quot;Item1&quot;]\"',          \"expanded={tpec_TpExPr_expa_TPMDL_0}\",          'updateVars=\"expanded=tpec_TpExPr_expa_TPMDL_0',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_tree_html_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"value\", \"Item 1\")      html_string = '<taipy:tree lov=\"Item 1;Item 2;Item 3\">{value}</taipy:tree>'      expected_list = [          \"<TreeView\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_value_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_value_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_tree_html_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"value\", \"Item 1\")      html_string = '<taipy:tree lov=\"Item 1;Item 2;Item 3\" value=\"{value}\" />'      expected_list = [          \"<TreeView\",          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;]\"',          'defaultValue=\"[&quot;Item 1&quot;]\"',          'updateVarName=\"_TpLv_tpec_TpExPr_value_TPMDL_0\"',          \"value={_TpLv_tpec_TpExPr_value_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_expandable_md_1(gui: Gui, helpers):      md_string = \"\"\"  <|Expandable section|expandable|not expanded|  # This is an expandable section  |>  \"\"\"      expected_list = [          \"<Expandable\",          \"expanded={false}\",          'title=\"Expandable section\"',          \"<h1\",          \"This is an expandable section\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_expandable_md_2(gui: Gui, helpers):      md_string = \"\"\"  <|expandable.start|title=Expandable section|not expanded|>  # This is an expandable section  <|expandable.end|>  \"\"\"      expected_list = [          \"<Expandable\",          \"expanded={false}\",          'title=\"Expandable section\"',          \"<h1\",          \"This is an expandable section\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_expandable_html(gui: Gui, helpers):      html_string = '<taipy:expandable title=\"Expandable section\" expanded=\"false\"><h1>This is an expandable section</h1></taipy:expandable >'      expected_list = [          \"<Expandable\",          \"expanded={false}\",          'title=\"Expandable section\"',          \"<h1\",          \"This is an expandable section\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from datetime import datetime    from taipy.gui import Gui      def test_date_range_md_1(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"dates\", [datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"), datetime.strptime(\"31 Dec 2020\", \"%d %b %Y\")]      )      md_string = \"<|{dates}|date_range|>\"      expected_list = [          \"<DateRange\",          'defaultDates=\"[&quot;2020-12-',          'updateVarName=\"_TpDr_tpec_TpExPr_dates_TPMDL_0\"',          \"dates={_TpDr_tpec_TpExPr_dates_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_date_range_md_2(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"dates\", [datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"), datetime.strptime(\"31 Dec 2020\", \"%d %b %Y\")]      )      md_string = \"<|{dates}|date_range|with_time|label_start=start|label_end=end|>\"      expected_list = [          \"<DateRange\",          'defaultDates=\"[&quot;2020-12-',          'updateVarName=\"_TpDr_tpec_TpExPr_dates_TPMDL_0\"',          \"dates={_TpDr_tpec_TpExPr_dates_TPMDL_0}\",          \"withTime={true}\",          'labelStart=\"start\"',          'labelEnd=\"end\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_date_range_html_1(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"dates\", [datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"), datetime.strptime(\"31 Dec 2020\", \"%d %b %Y\")]      )      html_string = '<taipy:date_range dates=\"{dates}\" />'      expected_list = [          \"<DateRange\",          'defaultDates=\"[&quot;2020-12-',          'updateVarName=\"_TpDr_tpec_TpExPr_dates_TPMDL_0\"',          \"dates={_TpDr_tpec_TpExPr_dates_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_date_range_html_2(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"dates\", [datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"), datetime.strptime(\"31 Dec 2020\", \"%d %b %Y\")]      )      html_string = \"<taipy:date_range>{dates}</taipy:date_range>\"      expected_list = [          \"<DateRange\",          'defaultDates=\"[&quot;2020-12-',          'updateVarName=\"_TpDr_tpec_TpExPr_dates_TPMDL_0\"',          \"dates={_TpDr_tpec_TpExPr_dates_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "import os  import pathlib  from importlib import util    from taipy.gui import Gui      def test_image_url_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", \"some_url\")      md_string = \"<|{content}|image|>\"      expected_list = [          \"<Image\",          \"content={_TpCi_tpec_TpExPr_content_TPMDL_0}\",          'defaultContent=\"some_url\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_image_file_md(gui: Gui, test_client, helpers):      with open((pathlib.Path(__file__).parent.parent / \"resources\" / \"fred.png\").resolve(), \"rb\") as content:          gui._bind_var_val(\"content\", content.read())          md_string = \"<|{content}|image|>\"          expected_list = [              \"<Image\",              'defaultContent=\"data:image/png;base64,',          ]          if not util.find_spec(\"magic\"):              expected_list = [\"<Image\", 'defaultContent=\"/taipy-content/taipyStatic0/TaiPyContent.', \".bin\"]          helpers.test_control_md(gui, md_string, expected_list)      def test_image_path_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", str((pathlib.Path(__file__).parent.parent / \"resources\" / \"fred.png\").resolve()))      md_string = \"<|{content}|image|>\"      expected_list = [          \"<Image\",          'defaultContent=\"/taipy-content/taipyStatic0/fred.png',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_image_bad_file_md(gui: Gui, test_client, helpers):      with open(os.path.abspath(__file__), \"rb\") as content:          gui._bind_var_val(\"content\", content.read())          md_string = \"<|{content}|image|>\"          expected_list = [              \"<Image\",              'defaultContent=\"Invalid content: text/x',          ]          if not util.find_spec(\"magic\"):              expected_list = [\"<Image\", 'defaultContent=\"/taipy-content/taipyStatic0/TaiPyContent.', \".bin\"]          helpers.test_control_md(gui, md_string, expected_list)      def test_image_url_html(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", \"some_url\")      html_string = '<taipy:image content=\"{content}\" on_action=\"action\" />'      expected_list = [          \"<Image\",          'defaultContent=\"some_url\"',          'onAction=\"action\"',      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import inspect    from taipy.gui import Gui      def test_status_md(gui: Gui, helpers):      status = [{\"status\": \"info\", \"message\": \"Info Message\"}]  # noqa: F841      md_string = \"<|{status}|status|>\"      expected_list = [          \"<Status\",          'defaultValue=\"[&#x7B;&quot;status&quot;: &quot;info&quot;, &quot;message&quot;: &quot;Info Message&quot;&#x7D;]\"',          \"value={tpec_TpExPr_status_TPMDL_0}\",      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_md(gui, md_string, expected_list)      def test_status_html(gui: Gui, helpers):      status = [{\"status\": \"info\", \"message\": \"Info Message\"}]  # noqa: F841      html_string = '<taipy:status value=\"{status}\" />'      expected_list = [          \"<Status\",          'defaultValue=\"[&#x7B;&quot;status&quot;: &quot;info&quot;, &quot;message&quot;: &quot;Info Message&quot;&#x7D;]\"',          \"value={tpec_TpExPr_status_TPMDL_0}\",      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_toggle_md(gui: Gui, helpers):      md_string = \"<|toggle|theme|>\"      expected_list = [\"<Toggle\", 'kind=\"theme\"', 'unselectedValue=\"\"']      helpers.test_control_md(gui, md_string, expected_list)      def test_toggle_allow_unselected_md(gui: Gui, helpers):      md_string = \"<|toggle|lov=1;2|allow_unselect|>\"      expected_list = [\"<Toggle\", 'unselectedValue=\"\"', \"allowUnselect={true}\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_toggle_lov_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"l1\")      gui._bind_var_val(\"lov\", [(\"l1\", \"v1\"), (\"l2\", \"v2\")])      md_string = \"<|{x}|toggle|lov={lov}|label=Label|>\"      expected_list = [          \"<Toggle\",          'defaultLov=\"[[&quot;l1&quot;, &quot;v1&quot;], [&quot;l2&quot;, &quot;v2&quot;]]\"',          'defaultValue=\"l1\"',          'label=\"Label\"',          \"lov={_TpL_tpec_TpExPr_lov_TPMDL_0}\",          'updateVars=\"lov=_TpL_tpec_TpExPr_lov_TPMDL_0\"',          'updateVarName=\"_TpLv_tpec_TpExPr_x_TPMDL_0\"',          'unselectedValue=\"\"',          \"value={_TpLv_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_toggle_html_1(gui: Gui, helpers):      html_string = '<taipy:toggle theme=\"True\" />'      expected_list = [\"<Toggle\", 'kind=\"theme\"', 'unselectedValue=\"\"']      helpers.test_control_html(gui, html_string, expected_list)      def test_toggle_html_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"l1\")      gui._bind_var_val(\"lov\", [(\"l1\", \"v1\"), (\"l2\", \"v2\")])      html_string = '<taipy:toggle lov=\"{lov}\" label=\"Label\">{x}</taipy:toggle>'      expected_list = [          \"<Toggle\",          'defaultLov=\"[[&quot;l1&quot;, &quot;v1&quot;], [&quot;l2&quot;, &quot;v2&quot;]]\"',          'defaultValue=\"l1\"',          'label=\"Label\"',          \"lov={_TpL_tpec_TpExPr_lov_TPMDL_0}\",          'updateVars=\"lov=_TpL_tpec_TpExPr_lov_TPMDL_0\"',          'updateVarName=\"_TpLv_tpec_TpExPr_x_TPMDL_0\"',          'unselectedValue=\"\"',          \"value={_TpLv_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_pane_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"show_pane\", False)      md_string = \"\"\"  <|{show_pane}|pane|not persistent|  # This is a Pane  |>  \"\"\"      expected_list = [          \"<Pane\",          'anchor=\"left\"',          'updateVarName=\"_TpB_tpec_TpExPr_show_pane_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_show_pane_TPMDL_0}\",          \"<h1\",          \"This is a Pane</h1></Pane>\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_pane_persistent_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"show_pane\", False)      md_string = \"\"\"  <|{show_pane}|pane|persistent|  # This is a Pane  |>  \"\"\"      expected_list = [          \"<Pane\",          'anchor=\"left\"',          \"persistent={true}\",          'updateVarName=\"_TpB_tpec_TpExPr_show_pane_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_show_pane_TPMDL_0}\",          \"<h1\",          \"This is a Pane</h1></Pane>\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_pane_html(gui: Gui, test_client, helpers):      gui._bind_var_val(\"show_pane\", False)      html_string = '<taipy:pane open=\"{show_pane}\" persistent=\"false\"><h1>This is a Pane</h1></taipy:pane>'      expected_list = [          \"<Pane\",          'anchor=\"left\"',          'updateVarName=\"_TpB_tpec_TpExPr_show_pane_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_show_pane_TPMDL_0}\",          \"<h1\",          \"This is a Pane</h1></Pane>\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_text_md_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      md_string = \"<|{x}|>\"      expected_list = [\"<Field\", 'dataType=\"int\"', 'defaultValue=\"10\"', \"value={tpec_TpExPr_x_TPMDL_0}\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_text_html_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      html_string = '<taipy:text value=\"{x}\" />'      expected_list = [\"<Field\", 'dataType=\"int\"', 'defaultValue=\"10\"', \"value={tpec_TpExPr_x_TPMDL_0}\"]      helpers.test_control_html(gui, html_string, expected_list)      def test_text_html_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      html_string = \"<taipy:text>{x}</taipy:text>\"      expected_list = [\"<Field\", 'dataType=\"int\"', 'defaultValue=\"10\"', \"value={tpec_TpExPr_x_TPMDL_0}\"]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "import os  import pathlib  from importlib import util    from taipy.gui import Gui      def test_file_download_url_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", \"some_url\")      md_string = \"<|{content}|file_download|>\"      expected_list = [          \"<FileDownload\",          \"content={_TpC_tpec_TpExPr_content_TPMDL_0}\",          'defaultContent=\"some_url\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_file_download_file_md(gui: Gui, test_client, helpers):      with open((pathlib.Path(__file__).parent.parent / \"resources\" / \"fred.png\").resolve(), \"rb\") as content:          gui._bind_var_val(\"content\", content.read())          md_string = \"<|{content}|file_download|>\"          expected_list = [              \"<FileDownload\",              'defaultContent=\"data:image/png;base64,',          ]          if not util.find_spec(\"magic\"):              expected_list = [\"<FileDownload\", 'defaultContent=\"/taipy-content/taipyStatic0/TaiPyContent.', \".bin\"]          helpers.test_control_md(gui, md_string, expected_list)      def test_file_download_path_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", str((pathlib.Path(__file__).parent.parent / \"resources\" / \"fred.png\").resolve()))      md_string = \"<|{content}|file_download|>\"      expected_list = [          \"<FileDownload\",          'defaultContent=\"/taipy-content/taipyStatic0/fred.png',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_file_download_any_file_md(gui: Gui, test_client, helpers):      with open(os.path.abspath(__file__), \"rb\") as content:          gui._bind_var_val(\"content\", content.read())          md_string = \"<|{content}|file_download|>\"          expected_list = [              \"<FileDownload\",              'defaultContent=\"data:text/x',              \"python;base64,\",          ]          if not util.find_spec(\"magic\"):              expected_list = [\"<FileDownload\", 'defaultContent=\"/taipy-content/taipyStatic0/TaiPyContent.', \".bin\"]          helpers.test_control_md(gui, md_string, expected_list)      def test_file_download_url_html(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", \"some_url\")      html_string = '<taipy:file_download content=\"{content}\" />'      expected_list = [          \"<FileDownload\",          'defaultContent=\"some_url\"',      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_file_selector_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", None)      md_string = \"<|{content}|file_selector|label=label|on_action=action|>\"      expected_list = [          \"<FileSelector\",          'updateVarName=\"tpec_TpExPr_content_TPMDL_0\"',          'label=\"label\"',          'onAction=\"action\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_file_selector_html(gui: Gui, test_client, helpers):      gui._bind_var_val(\"content\", None)      html_string = '<taipy:file_selector content=\"{content}\" label=\"label\" on_action=\"action\" />'      expected_list = [          \"<FileSelector\",          'updateVarName=\"tpec_TpExPr_content_TPMDL_0\"',          'label=\"label\"',          'onAction=\"action\"',      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_content_md(gui: Gui, helpers):      md_string = \"<|content|>\"      expected_list = [\"<PageContent\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_content_html(gui: Gui, helpers):      html_string = \"<taipy:content />\"      expected_list = [\"<PageContent\"]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "import inspect    from taipy.gui import Gui, Markdown      def test_dialog_md_1(gui: Gui, helpers):      dialog_open = False  # noqa: F841      gui._set_frame(inspect.currentframe())      md_string = \"<|dialog|title=This is a Dialog|open={dialog_open}|page=page_test|on_action=validate_action|>\"      expected_list = [          \"<Dialog\",          'onAction=\"validate_action\"',          'page=\"page_test\"',          'title=\"This is a Dialog\"',          'updateVarName=\"_TpB_tpec_TpExPr_dialog_open_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_dialog_open_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_dialog_md_2(gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      partial = gui.add_partial(Markdown(\"# A partial\"))  # noqa: F841      dialog_open = False  # noqa: F841      md_string = \"<|dialog|title=Another Dialog|open={dialog_open}|partial={partial}|on_action=validate_action|>\"      expected_list = [          \"<Dialog\",          'page=\"TaiPy_partials',          'title=\"Another Dialog\"',          'onAction=\"validate_action\"',          'updateVarName=\"_TpB_tpec_TpExPr_dialog_open_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_dialog_open_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_dialog_labels_md(gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      dialog_open = False  # noqa: F841      md_string = (          \"<|dialog|title=Another Dialog|open={dialog_open}|page=page_test|labels=Cancel;Validate|close_label=MYClose|>\"      )      expected_list = [          \"<Dialog\",          'page=\"page_test\"',          'title=\"Another Dialog\"',          'labels=\"[&quot;Cancel&quot;, &quot;Validate&quot;]\"',          'updateVarName=\"_TpB_tpec_TpExPr_dialog_open_TPMDL_0\"',          'closeLabel=\"MYClose\"',          \"open={_TpB_tpec_TpExPr_dialog_open_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_dialog_html_1(gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      dialog_open = False  # noqa: F841      html_string = (          '<taipy:dialog title=\"This is a Dialog\" open=\"{dialog_open}\" page=\"page1\" on_action=\"validate_action\" />'      )      expected_list = [          \"<Dialog\",          'page=\"page1\"',          'title=\"This is a Dialog\"',          'onAction=\"validate_action\"',          'updateVarName=\"_TpB_tpec_TpExPr_dialog_open_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_dialog_open_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_dialog_html_2(gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      partial = gui.add_partial(Markdown(\"# A partial\"))  # noqa: F841      dialog_open = False  # noqa: F841      html_string = (          '<taipy:dialog title=\"Another Dialog\" open=\"{dialog_open}\" partial=\"{partial}\" on_action=\"validate_action\" />'      )      expected_list = [          \"<Dialog\",          'page=\"TaiPy_partials',          'title=\"Another Dialog\"',          'onAction=\"validate_action\"',          'updateVarName=\"_TpB_tpec_TpExPr_dialog_open_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_dialog_open_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_dialog_labels_html(gui: Gui, helpers):      gui._set_frame(inspect.currentframe())      dialog_open = False  # noqa: F841      html_string = (          '<taipy:dialog title=\"Another Dialog\" open=\"{dialog_open}\" page=\"page_test\" labels=\"Cancel;Validate\" />'      )      expected_list = [          \"<Dialog\",          'page=\"page_test\"',          'title=\"Another Dialog\"',          'labels=\"[&quot;Cancel&quot;, &quot;Validate&quot;]\"',          'updateVarName=\"_TpB_tpec_TpExPr_dialog_open_TPMDL_0\"',          \"open={_TpB_tpec_TpExPr_dialog_open_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_menu_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"lov\", [\"Item 1\", \"Item 2\", \"Item 3\", \"Item 4\"])      md_string = \"<|menu|lov={lov}|on_action=on_menu_action|>\"      expected_list = [          \"<MenuCtl\",          'libClassName=\"taipy-menu\"',          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;, &quot;Item 4&quot;]\"',          \"lov={_TpL_tpec_TpExPr_lov_TPMDL_0}\",          'onAction=\"on_menu_action\"',          'updateVars=\"lov=_TpL_tpec_TpExPr_lov_TPMDL_0\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_menu_html(gui: Gui, test_client, helpers):      gui._bind_var_val(\"lov\", [\"Item 1\", \"Item 2\", \"Item 3\", \"Item 4\"])      html_string = '<taipy:menu lov=\"{lov}\" />'      expected_list = [          \"<MenuCtl\",          'libClassName=\"taipy-menu\"',          'defaultLov=\"[&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;, &quot;Item 4&quot;]\"',          \"lov={_TpL_tpec_TpExPr_lov_TPMDL_0}\",          'updateVars=\"lov=_TpL_tpec_TpExPr_lov_TPMDL_0\"',      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_layout_md_1(gui: Gui, helpers):      md_string = \"\"\"  <|layout|columns=1 1|gap=1rem|  # This is a layout section  |>  \"\"\"      expected_list = [\"<Layout\", 'columns=\"1 1', 'gap=\"1rem\"', \"<h1\", \"This is a layout section\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_layout_md_2(gui: Gui, helpers):      md_string = \"\"\"  <|layout.start|columns=1 1|gap=1rem|>  # This is a layout section  <|layout.end|>  \"\"\"      expected_list = [\"<Layout\", 'columns=\"1 1', 'gap=\"1rem\"', \"<h1\", \"This is a layout section\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_layout_html(gui: Gui, helpers):      html_string = '<taipy:layout columns=\"1 1\" gap=\"1rem\"><h1>This is a layout section</h1></taipy:layout>'      expected_list = [\"<Layout\", 'columns=\"1 1', 'gap=\"1rem\"', \"<h1\", \"This is a layout section\"]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_number_md_1(gui: Gui, helpers):      md_string = \"<|10|number|>\"      expected_list = [\"<Input\", 'value=\"10\"', 'type=\"number\"']      helpers.test_control_md(gui, md_string, expected_list)      def test_number_md_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", \"10\")      md_string = \"<|{x}|number|>\"      expected_list = [          \"<Input\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"10\"',          'type=\"number\"',          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_number_html_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      html_string = '<taipy:number value=\"{x}\" />'      expected_list = [          \"<Input\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"10\"',          'type=\"number\"',          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_number_html_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"x\", 10)      html_string = \"<taipy:number>{x}</taipy:number>\"      expected_list = [          \"<Input\",          'updateVarName=\"_TpN_tpec_TpExPr_x_TPMDL_0\"',          'defaultValue=\"10\"',          'type=\"number\"',          \"value={_TpN_tpec_TpExPr_x_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from datetime import datetime    from taipy.gui import Gui      def test_date_md_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"date\", datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"))      md_string = \"<|{date}|date|>\"      expected_list = [          \"<DateSelector\",          'defaultDate=\"2020-12-',          'updateVarName=\"_TpDt_tpec_TpExPr_date_TPMDL_0\"',          \"date={_TpDt_tpec_TpExPr_date_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_date_md_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"date\", datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"))      md_string = \"<|{date}|date|with_time|label=a label|>\"      expected_list = [          \"<DateSelector\",          'defaultDate=\"2020-12-',          'updateVarName=\"_TpDt_tpec_TpExPr_date_TPMDL_0\"',          \"date={_TpDt_tpec_TpExPr_date_TPMDL_0}\",          \"withTime={true}\",          'label=\"a label\"',      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_date_html_1(gui: Gui, test_client, helpers):      gui._bind_var_val(\"date\", datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"))      html_string = '<taipy:date date=\"{date}\" />'      expected_list = [          \"<DateSelector\",          'defaultDate=\"2020-12-',          'updateVarName=\"_TpDt_tpec_TpExPr_date_TPMDL_0\"',          \"date={_TpDt_tpec_TpExPr_date_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_date_html_2(gui: Gui, test_client, helpers):      gui._bind_var_val(\"date\", datetime.strptime(\"15 Dec 2020\", \"%d %b %Y\"))      html_string = \"<taipy:date>{date}</taipy:date>\"      expected_list = [          \"<DateSelector\",          'defaultDate=\"2020-12-',          'updateVarName=\"_TpDt_tpec_TpExPr_date_TPMDL_0\"',          \"date={_TpDt_tpec_TpExPr_date_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_indicator_md(gui: Gui, test_client, helpers):      gui._bind_var_val(\"val\", 15)      md_string = \"<|12|indicator|value={val}|min=1|max=20|format=%.2f|>\"      expected_list = [          \"<Indicator\",          'libClassName=\"taipy-indicator\"',          \"defaultValue={15}\",          \"display={12.0}\",          'format=\"%.2f\"',          \"max={20.0}\",          \"min={1.0}\",          \"value={_TpN_tpec_TpExPr_val_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_menu_html(gui: Gui, test_client, helpers):      gui._bind_var_val(\"val\", 15)      html_string = '<taipy:indicator value=\"{val}\" min=\"1\" max=\"20\" format=\"%.2f\" >12</taipy:indicator>'      expected_list = [          \"<Indicator\",          'libClassName=\"taipy-indicator\"',          \"defaultValue={15}\",          \"display={12.0}\",          'format=\"%.2f\"',          \"max={20.0}\",          \"min={1.0}\",          \"value={_TpN_tpec_TpExPr_val_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_navbar_md(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"navlov\",          [              (\"/page1\", \"Page 1\"),              (\"/page2\", \"Page 2\"),              (\"/page3\", \"Page 3\"),              (\"/page4\", \"Page 4\"),          ],      )      md_string = \"<|navbar|lov={navlov}|>\"      expected_list = [          \"<NavBar\",          'defaultLov=\"[[&quot;/page1&quot;, &quot;Page 1&quot;], [&quot;/page2&quot;, &quot;Page 2&quot;], [&quot;/page3&quot;, &quot;Page 3&quot;], [&quot;/page4&quot;, &quot;Page 4&quot;]]\"',          \"lov={_TpL_tpec_TpExPr_navlov_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_navbar_html(gui: Gui, test_client, helpers):      gui._bind_var_val(          \"navlov\",          [              (\"/page1\", \"Page 1\"),              (\"/page2\", \"Page 2\"),              (\"/page3\", \"Page 3\"),              (\"/page4\", \"Page 4\"),          ],      )      html_string = '<taipy:navbar lov=\"{navlov}\" />'      expected_list = [          \"<NavBar\",          'defaultLov=\"[[&quot;/page1&quot;, &quot;Page 1&quot;], [&quot;/page2&quot;, &quot;Page 2&quot;], [&quot;/page3&quot;, &quot;Page 3&quot;], [&quot;/page4&quot;, &quot;Page 4&quot;]]\"',          \"lov={_TpL_tpec_TpExPr_navlov_TPMDL_0}\",      ]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "from taipy.gui import Gui      def test_part_md_1(gui: Gui, helpers):      md_string = \"\"\"  <|part|class_name=class1|  # This is a part  |>  \"\"\"      expected_list = [\"<Part\", \"<h1\", \"This is a part\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_part_md_2(gui: Gui, helpers):      md_string = \"\"\"  <|part.start|class_name=class1|>  # This is a part  <|part.end|>  \"\"\"      expected_list = [\"<Part\", \"<h1\", \"This is a part\"]      helpers.test_control_md(gui, md_string, expected_list)      def test_part_html(gui: Gui, helpers):      html_string = '<taipy:part class_name=\"class1\"><h1>This is a part</h1></taipy:part>'      expected_list = [\"<Part\", \"<h1\", \"This is a part\"]      helpers.test_control_html(gui, html_string, expected_list) "}
{"text": "import random  import string    from example_library import ExampleLibrary    from taipy.gui import Gui    # Initial value  label = \"Here is some text\"    page = \"\"\"  # Custom elements example    ## Fraction:    No denominator: <|123|example.fraction|>    Denominator is 0: <|321|example.fraction|denominator=0|>    Regular: <|355|example.fraction|denominator=113|>    ## Custom label:    Colored text: <|{label}|example.label|>    <|Add a character|button|id=addChar|>  <|Remove a character|button|id=removeChar|>  \"\"\"      def on_action(state, id):      if id == \"addChar\":          # Add a random character to the end of 'label'          state.label += random.choice(string.ascii_letters)      elif id == \"removeChar\":          # Remove the first character of 'label'          if len(state.label) > 0:              state.label = state.label[1:]      Gui(page, libraries=[ExampleLibrary()]).run(debug=True) "}
{"text": "from .example_library import ExampleLibrary "}
{"text": "from taipy.gui.extension import Element, ElementLibrary, ElementProperty, PropertyType      class ExampleLibrary(ElementLibrary):      def __init__(self) -> None:          # Initialize the set of visual elements for this extension library          self.elements = {              # A static element that displays its properties in a fraction              \"fraction\": Element(                  \"numerator\",                  {                      \"numerator\": ElementProperty(PropertyType.number),                      \"denominator\": ElementProperty(PropertyType.number),                  },                  render_xhtml=ExampleLibrary._fraction_render,              ),              # A dynamic element that decorates its value              \"label\": Element(                  \"value\",                  {\"value\": ElementProperty(PropertyType.dynamic_string)},                  # The name of the React component (ColoredLabel) that implements this custom                  # element, exported as ExampleLabel in front-end/src/index.ts                  react_component=\"ExampleLabel\",              ),          }        # The implementation of the rendering for the \"fraction\" static element      @staticmethod      def _fraction_render(props: dict) -> str:          # Get the property values          numerator = props.get(\"numerator\")          denominator = props.get(\"denominator\")          # No denominator or numerator is 0: display the numerator          if denominator is None or int(numerator) == 0:              return f\"<span>{numerator}</span>\"          # Denominator is zero: display infinity          if int(denominator) == 0:              return '<span style=\"font-size: 1.6em\">&#8734;</span>'          # 'Normal' case          return f\"<span><sup>{numerator}</sup>/<sub>{denominator}</sub></span>\"        def get_name(self) -> str:          return \"example\"        def get_elements(self) -> dict:          return self.elements        def get_scripts(self) -> list[str]:          # Only one JavaScript bundle for this library.          return [\"front-end/dist/exampleLibrary.js\"] "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  # Demonstrate how to share variable values across multiple clients.  # This application creates a thread that increments a value every few seconds.  # The value is updated for every client using the state.broadcast() method.  # The text of the button that starts or stops the thread is updated on every client's browser  # using a direct assignment of the state property because the variable is declared 'shared'.  # -----------------------------------------------------------------------------------------  from threading import Event, Thread  from time import sleep    from taipy.gui import Gui, State, broadcast_callback    counter = 0    # Thread management  thread = None  thread_event = Event()    button_texts = [\"Start\", \"Stop\"]  # Text in the start/stop button (initially \"Start\")  button_text = button_texts[0]      # Invoked by the timer  def update_counter(state: State, c):      # Update all clients      state.broadcast(\"counter\", c)      def count(event, gui):      while not event.is_set():          global counter          counter = counter + 1          broadcast_callback(gui, update_counter, [counter])          sleep(2)      # Start or stop the timer when the button is pressed  def start_or_stop(state):      global thread      if thread:  # Timer is running          thread_event.set()          thread = None      else:  # Timer is stopped          thread_event.clear()          thread = Thread(target=count, args=[thread_event, state.get_gui()])          thread.start()      # Update button status.      # Because \"button_text\" is shared, all clients are updated      state.button_text = button_texts[1 if thread else 0]      page = \"\"\"# Broadcasting values    Counter: <|{counter}|>    Timer: <|{button_text}|button|on_action=start_or_stop|>  \"\"\"    # Declare \"button_text\" as a shared variable.  # Assigning a value to a state's 'button_text' property is propagated to all clients  Gui.add_shared_variable(\"button_text\")    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  # Demonstrates the use of the 'rebuild' property of the 'chart' control  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # x values: [-10..10]  x_range = range(-10, 11)  data = {\"X\": x_range, \"Y\": [x * x for x in x_range]}    types = [(\"bar\", \"Bar\"), (\"line\", \"Line\")]  selected_type = types[0]    page = \"\"\"  <|{data}|chart|type={selected_type[0]}|x=X|y=Y|rebuild|>    <|{selected_type}|toggle|lov={types}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import datetime    from taipy.gui import Gui    # Tasks definitions  tasks = [\"Plan\", \"Research\", \"Design\", \"Implement\", \"Test\", \"Deliver\"]  # Task durations, in days  durations = [50, 30, 30, 40, 15, 10]  # Planned start dates of tasks  start_dates = [      datetime.date(2022, 10, 15),  # Plan      datetime.date(2022, 11, 7),  # Research      datetime.date(2022, 12, 1),  # Design      datetime.date(2022, 12, 20),  # Implement      datetime.date(2023, 1, 15),  # Test      datetime.date(2023, 2, 1),  # Deliver  ]    epoch = datetime.date(1970, 1, 1)    data = {      \"start\": start_dates,      \"Task\": tasks,      # Compute the time span as adatetime (relative to January 1st, 1970)      \"Date\": [epoch + datetime.timedelta(days=duration) for duration in durations],  }    layout = {      \"yaxis\": {          # Sort tasks from top to bottom          \"autorange\": \"reversed\",          # Remove title          \"title\": {\"text\": \"\"},      },  }    page = \"\"\"  # Gantt - Simple    <|{data}|chart|type=bar|orientation=h|y=Task|x=Date|base=start|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # x values are [-10..10]  x_range = range(-10, 11)    # The data set that holds both the x and the y values  data = {\"X\": x_range, \"Y\": [x * x for x in x_range]}    page = \"\"\"  # Basics - X range    <|{data}|chart|x=X|y=Y|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui      # Function to plot: x^3/3-x  def f(x):      return x * x * x / 3 - x      # x values: [-2.2, ..., 2.2]  x = [(x - 10) / 4.5 for x in range(0, 21)]    data = {      \"x\": x,      # y: [f(-2.2), ..., f(2.2)]      \"y\": [f(x) for x in x],  }    shape_size = 0.1    layout = {      \"shapes\": [          # Shape for local maximum (x = -1)          {              \"x0\": -1 - shape_size,              \"y0\": f(-1) - 2 * shape_size,              \"x1\": -1 + shape_size,              \"y1\": f(-1) + 2 * shape_size,              \"fillcolor\": \"green\",              \"opacity\": 0.5,          },          # Shape for local minimum (x = 1)          {              \"x0\": 1 - shape_size,              \"y0\": f(1) - 2 * shape_size,              \"x1\": 1 + shape_size,              \"y1\": f(1) + 2 * shape_size,              \"fillcolor\": \"red\",              \"opacity\": 0.5,          },      ]  }    page = \"\"\"  # Advanced - Annotations    <|{data}|chart|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import numpy    from taipy.gui import Gui      # Return the x and y coordinates of the spiral for the given angle  def spiral(th):      a = 1.120529      b = 0.306349      r = a * numpy.exp(-b * th)      return (r * numpy.cos(th), r * numpy.sin(th))      # Prepare Golden spiral data as a parametric curve  (x, y) = spiral(numpy.linspace(-numpy.pi / 13, 4 * numpy.pi, 1000))    # Prepare the heatmap x and y cell sizes along the axes  golden_ratio = (1 + numpy.sqrt(5)) / 2.0  # Golden ratio  grid_x = [0, 1, 1 + (1 / (golden_ratio**4)), 1 + (1 / (golden_ratio**3)), golden_ratio]  grid_y = [0, 1 / (golden_ratio**3), 1 / golden_ratio**3 + 1 / golden_ratio**4, 1 / (golden_ratio**2), 1]    # Main value is based on the Fibonacci sequence  z = [[13, 3, 3, 5], [13, 2, 1, 5], [13, 10, 11, 12], [13, 8, 8, 8]]    # Group all data sets in a single array  data = [      {          \"z\": z,      },      {\"x\": numpy.sort(grid_x), \"y\": numpy.sort(grid_y)},      {          \"xSpiral\": -x + x[0],          \"ySpiral\": y - y[0],      },  ]    # Axis template: hide all ticks, lines and labels  axis = {\"range\": [0, 2.0], \"showgrid\": False, \"zeroline\": False, \"showticklabels\": False, \"ticks\": \"\", \"title\": \"\"}    layout = {      # Use the axis template for both x and y axes      \"xaxis\": axis,      \"yaxis\": axis,  }    options = {      # Hide the color scale of the heatmap      \"showscale\": False  }    # Chart holds two traces, with different types  types = [\"heatmap\", \"scatter\"]  # x and y values for both traces  xs = [\"1/x\", \"2/xSpiral\"]  ys = [\"1/y\", \"2/ySpiral\"]    page = \"\"\"  ## Heatmap - Drawing on top    <|{data}|chart|type={types}|z[1]=0/z|x={xs}|y={ys}|layout={layout}|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    from taipy.gui import Gui    # Data set made of two series of random numbers  data = {\"A\": [random.random() for i in range(200)], \"B\": [random.random() for i in range(200)]}    # Names of the two traces  names = [\"A samples\", \"B samples\"]    layout = {      # Make the histogram stack the data sets      \"barmode\": \"stack\"  }    page = \"\"\"  # Histogram - Stacked    <|{data}|chart|type=histogram|x[1]=A|x[2]=B|name={names}|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Data set  data = {      \"Day\": [\"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\"],      \"Values\": [10, -5, 20, -10, 30],      \"Measure\": [\"absolute\", \"relative\", \"relative\", \"relative\", \"relative\"],  }    page = \"\"\"  # Waterfall - Simple    <|{data}|chart|type=waterfall|x=Day|y=Values|measure=Measure|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    n_slices = 20  # List: [1..n_slices]  # Slices are bigger and bigger  values = list(range(1, n_slices + 1))    marker = {      # Colors move around the Hue color disk      \"colors\": [f\"hsl({360 * (i - 1)/(n_slices - 1)},90%,60%)\" for i in values]  }    layout = {      # Hide the legend      \"showlegend\": False  }    options = {      # Hide the texts      \"textinfo\": \"none\"  }    page = \"\"\"  # Pie - Style    <|{values}|chart|type=pie|marker={marker}|options={options}|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from datetime import datetime    import numpy    from taipy.gui import Gui      def generate_hand_shapes():      # Retrieve and store the current, local time      time_now = datetime.now()      hours = time_now.hour      minutes = time_now.minute      seconds = time_now.second        # Compute the angle that represents the hours      hours_angle = 360 * ((hours % 12) / 12 + (minutes % 60) / 60 / 60 + (seconds % 60) / 60 / 60 / 60)      # Short and thick hand for the hours      hours_hand = {\"r\": [0, 4, 5, 4, 0], \"a\": [0, hours_angle - 7, hours_angle, hours_angle + 7, 0]}        # Compute the angle that represents the minutes      minutes_angle = 360 * ((minutes % 60) / 60 + (seconds % 60) / 60 / 60)      # Longer and slighly thinner hand for the minutes      minutes_hand = {\"r\": [0, 6, 8, 6, 0], \"a\": [0, minutes_angle - 4, minutes_angle, minutes_angle + 4, 0]}        # Compute the angle that represents the seconds      seconds_angle = 360 * (seconds % 60) / 60      # Even longer and thinner hand for the seconds      seconds_hand = {\"r\": [0, 8, 10, 8, 0], \"a\": [0, seconds_angle - 2, seconds_angle, seconds_angle + 2, 0]}      # Build and return the whole data set      return [hours_hand, minutes_hand, seconds_hand]      # Initialize the data set with the current time  data = generate_hand_shapes()    layout = {      \"polar\": {          \"angularaxis\": {              \"rotation\": 90,              \"direction\": \"clockwise\",              # One tick every 30 degrees              \"tickvals\": list(numpy.arange(0.0, 360.0, 30)),              # Text value for every tick              \"ticktext\": [\"XII\", \"I\", \"II\", \"III\", \"IV\", \"V\", \"VI\", \"VII\", \"VIII\", \"IX\", \"X\", \"XI\"],          },          \"radialaxis\": {\"angle\": 90, \"visible\": False, \"range\": [0, 12]},      },      \"showlegend\": False,  }    # Options to be used for all three traces  base_opts = {\"fill\": \"toself\"}  # Specific for hours  hours_opts = dict(base_opts)  hours_opts[\"fillcolor\"] = \"#FF0000\"  # Specific for minutes  minutes_opts = dict(base_opts)  minutes_opts[\"fillcolor\"] = \"#00FF00\"  # Specific for seconds  seconds_opts = dict(base_opts)  seconds_opts[\"fillcolor\"] = \"#0000FF\"    # Store all the chart control properties in a single object  properties = {      # Don't show data point markers      \"mode\": \"lines\",      # Data for the hours      \"theta[1]\": \"0/a\",      \"r[1]\": \"0/r\",      # Data for the minutes      \"theta[2]\": \"1/a\",      \"r[2]\": \"1/r\",      # Data for the seconds      \"theta[3]\": \"2/a\",      \"r[3]\": \"2/r\",      # Options for the three traces      \"options[1]\": hours_opts,      \"options[2]\": minutes_opts,      \"options[3]\": seconds_opts,      \"line\": {\"color\": \"black\"},      \"layout\": layout,  }      # Update time on every refresh  def on_navigate(state, page):      state.data = generate_hand_shapes()      return page      page = \"\"\"  # Polar - Tick texts    <|{data}|chart|type=scatterpolar|properties={properties}|>  \"\"\"  Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {\"Types\": [\"Visits\", \"Downloads\", \"Prospects\", \"Invoiced\", \"Closed\"], \"Visits\": [13873, 10533, 5443, 2703, 908]}    layout = {      # Stack the areas      \"funnelmode\": \"stack\",      # Hide the legend      \"showlegend\": False,  }    page = \"\"\"  # Funnel - Area    <|{data}|chart|type=funnelarea|values=Visits|text=Types|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import pandas    from taipy.gui import Gui    # Source https://en.wikipedia.org/wiki/List_of_United_States_presidential_elections_by_popular_vote_margin  percentages = [      (1852, 50.83),      (1856, 45.29),      (1860, 39.65),      (1864, 55.03),      (1868, 52.66),      (1872, 55.58),      (1876, 47.92),      (1880, 48.31),      (1884, 48.85),      (1888, 47.80),      (1892, 46.02),      (1896.0, 51.02),      (1900, 51.64),      (1904, 56.42),      (1908, 51.57),      (1912, 41.84),      (1916, 49.24),      (1920, 60.32),      (1924, 54.04),      (1928, 58.21),  ]    # Lost percentage = 100-Won percentage  full = [(t[0], t[1], 100 - t[1]) for t in percentages]    data = pandas.DataFrame(full, columns=[\"Year\", \"Won\", \"Lost\"])    layout = {\"barmode\": \"stack\"}    page = \"\"\"  # Bar - Stacked    <|{data}|chart|type=bar|x=Year|y[1]=Won|y[2]=Lost|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import numpy  import pandas    from taipy.gui import Gui    # Generate a random value for every hour on a given day  data = {\"Date\": pandas.date_range(\"2023-01-04\", periods=24, freq=\"H\"), \"Value\": pandas.Series(numpy.random.randn(24))}    page = \"\"\"  # Basics - Timeline    <|{data}|chart|x=Date|y=Value|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    from taipy.gui import Gui    # Data set made of two series of random numbers  data = [{\"x\": [random.random() + 1 for i in range(100)]}, {\"x\": [random.random() + 1.1 for i in range(100)]}]    options = [      # First data set displayed as semi-transparent, green bars      {\"opacity\": 0.5, \"marker\": {\"color\": \"green\"}},      # Second data set displayed as semi-transparent, gray bars      {\"opacity\": 0.5, \"marker\": {\"color\": \"#888\"}},  ]    layout = {      # Overlay the two histograms      \"barmode\": \"overlay\",      # Hide the legend      \"showlegend\": False,  }    page = \"\"\"  # Histogram - Overlay    <|{data}|chart|type=histogram|options={options}|layout={layout}|>  \"\"\"  Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"Day\": [\"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\"],      \"Items\": [32, 25, 86, 60, 70],      \"Price\": [80, 50, 140, 10, 70],  }    options = [      # For items      {\"fill\": \"tozeroy\"},      # For price      # Using \"tonexty\" not to cover the first trace      {\"fill\": \"tonexty\"},  ]    page = \"\"\"  # Filled Area - Overlay    <|{data}|chart|mode=none|x=Day|y[1]=Items|y[2]=Price|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # x values are [-10..10]  x_range = range(-10, 11)    # The data set holds the _x_ series and two distinct series for _y_  data = {      \"x\": x_range,      # y1 = x*x      \"y1\": [x * x for x in x_range],      # y2 = 100-x*x      \"y2\": [100 - x * x for x in x_range],  }    page = \"\"\"  # Basics - Multiple traces    <|{data}|chart|x=x|y[1]=y1|y[2]=y2|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  # Two data sets as a bar chart  import pandas    from taipy.gui import Gui    # Source https://en.wikipedia.org/wiki/List_of_United_States_presidential_elections_by_popular_vote_margin  percentages = [      (1852, 50.83),      (1856, 45.29),      (1860, 39.65),      (1864, 55.03),      (1868, 52.66),      (1872, 55.58),      (1876, 47.92),      (1880, 48.31),      (1884, 48.85),      (1888, 47.80),      (1892, 46.02),      (1896.0, 51.02),      (1900, 51.64),      (1904, 56.42),      (1908, 51.57),      (1912, 41.84),      (1916, 49.24),      (1920, 60.32),      (1924, 54.04),      (1928, 58.21),  ]  data = pandas.DataFrame(percentages, columns=[\"Year\", \"Won\"])  lost = [100 - t[1] for t in percentages]  data[\"Lost\"] = lost    page = \"\"\"  # Bar - Multiple    <|{data}|chart|type=bar|x=Year|y[1]=Won|y[2]=Lost|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # You may need to install the yfinance package as well.  # -----------------------------------------------------------------------------------------  import yfinance    from taipy import Gui    # Extraction of a month of stock data for AAPL using the  # yfinance package (see https://pypi.org/project/yfinance/).  ticker = yfinance.Ticker(\"AAPL\")  # The returned value is a Pandas DataFrame.  stock = ticker.history(interval=\"1d\", start=\"2018-08-01\", end=\"2018-08-31\")  # Copy the DataFrame's index to a new column  stock[\"Date\"] = stock.index    page = \"\"\"  # Candlestick - Simple    <|{stock}|chart|type=candlestick|x=Date|open=Open|close=Close|low=Low|high=High|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    import numpy    from taipy.gui import Gui    # x = [0..20]  x = list(range(0, 21))    data = {      \"x\": x,      # A list of random values within [1, 10]      \"y\": [random.uniform(1, 10) for _ in x],  }    layout = {      # Force the Box select tool      \"dragmode\": \"select\",      # Remove all margins around the plot      \"margin\": {\"l\": 0, \"r\": 0, \"b\": 0, \"t\": 0},  }    config = {      # Hide Plotly's mode bar      \"displayModeBar\": False  }    selected_indices = []    mean_value = 0.0      def on_change(state, var, val):      if var == \"selected_indices\":          state.mean_value = numpy.mean([data[\"y\"][idx] for idx in val]) if len(val) else 0      page = \"\"\"  # Advanced - Selection    ## Mean of <|{len(selected_indices)}|raw|> selected points: <|{mean_value}|format=%.2f|raw|>    <|{data}|chart|selected={selected_indices}|layout={layout}|plot_config={config}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import math  import random    from taipy.gui import Gui    # Number of samples  max_x = 20  # x values: [0..max_x-1]  x = range(0, max_x)  # Generate random sampling error margins  error_ranges = [random.uniform(0, 5) for _ in x]  # Compute a perfect sine wave  perfect_y = [10 * math.sin(4 * math.pi * i / max_x) for i in x]  # Compute a sine wave impacted by the sampling error  # The error is between \u00b1error_ranges[x]/2  y = [perfect_y[i] + random.uniform(-error_ranges[i] / 2, error_ranges[i] / 2) for i in x]    # The chart data is made of the three series  data = {      \"x\": x,      \"y1\": y,      \"y2\": perfect_y,  }    options = {      # Create the error bar information:      \"error_y\": {\"type\": \"data\", \"array\": error_ranges}  }    page = \"\"\"  # Error bars - Simple    <|{data}|chart|x=x|y[1]=y1|y[2]=y2|options[1]={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"Day\": [\"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\"],      \"Items\": [32, 25, 86, 60, 70],  }    options = {      # Fill to x axis      \"fill\": \"tozeroy\"  }    page = \"\"\"  # Filled Area - Simple    <|{data}|chart|x=Day|y=Items|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import datetime    import dateutil.relativedelta    from taipy.gui import Gui    # Data is collected from January 1st, 2010, every month  start_date = datetime.datetime(year=2010, month=1, day=1)  period = dateutil.relativedelta.relativedelta(months=1)    # Data  # All arrays have the same size (the number of months to track)  prices = {      # Data for apples      \"apples\": [2.48, 2.47, 2.5, 2.47, 2.46, 2.38, 2.31, 2.25, 2.39, 2.41, 2.59, 2.61],      \"apples_low\": [1.58, 1.58, 1.59, 1.64, 1.79, 1.54, 1.53, 1.61, 1.65, 2.02, 1.92, 1.54],      \"apples_high\": [3.38, 3.32, 2.63, 2.82, 2.58, 2.53, 3.27, 3.15, 3.44, 3.42, 3.08, 2.86],      \"bananas\": [2.94, 2.50, 2.39, 2.77, 2.43, 2.32, 2.37, 1.90, 2.31, 2.71, 3.38, 1.92],      \"bananas_low\": [2.12, 1.90, 1.69, 2.44, 1.58, 1.81, 1.44, 1.00, 1.59, 1.74, 2.78, 0.96],      \"bananas_high\": [3.32, 2.70, 3.12, 3.25, 3.00, 2.63, 2.54, 2.37, 2.97, 3.69, 4.36, 2.95],      \"cherries\": [6.18, None, None, None, 3.69, 2.46, 2.31, 2.57, None, None, 6.50, 4.38],      \"cherries_high\": [7.00, None, None, None, 8.50, 6.27, 5.61, 4.36, None, None, 8.00, 7.23],      \"cherries_low\": [3.55, None, None, None, 1.20, 0.87, 1.08, 1.50, None, None, 5.00, 4.20],  }    # Create monthly time series  months = [start_date + n * period for n in range(0, len(prices[\"apples\"]))]    data = [      # Raw data      {\"Months\": months, \"apples\": prices[\"apples\"], \"bananas\": prices[\"bananas\"], \"cherries\": prices[\"cherries\"]},      # Range data (twice as many values)      {          \"Months2\": months + list(reversed(months)),          \"apples\": prices[\"apples_high\"] + list(reversed(prices[\"apples_low\"])),          \"bananas\": prices[\"bananas_high\"] + list(reversed(prices[\"bananas_low\"])),          \"cherries\": prices[\"cherries_high\"] + list(reversed(prices[\"cherries_low\"])),      },  ]    properties = {      # First trace: reference for Apples      \"x[1]\": \"0/Months\",      \"y[1]\": \"0/apples\",      \"color[1]\": \"rgb(0,200,80)\",      #     Hide line      \"mode[1]\": \"markers\",      #     Show in the legend      \"name[1]\": \"Apples\",      # Second trace: reference for Bananas      \"x[2]\": \"0/Months\",      \"y[2]\": \"0/bananas\",      \"color[2]\": \"rgb(0,100,240)\",      #     Hide line      \"mode[2]\": \"markers\",      #     Show in the legend      \"name[2]\": \"Bananas\",      # Third trace: reference for Cherries      \"x[3]\": \"0/Months\",      \"y[3]\": \"0/cherries\",      \"color[3]\": \"rgb(240,60,60)\",      #     Hide line      \"mode[3]\": \"markers\",      #     Show in the legend      \"name[3]\": \"Cherries\",      # Fourth trace: range for Apples      \"x[4]\": \"1/Months2\",      \"y[4]\": \"1/apples\",      \"options[4]\": {          \"fill\": \"tozerox\",          \"showlegend\": False,          \"fillcolor\": \"rgba(0,100,80,0.4)\",      },      #      No surrounding stroke      \"color[4]\": \"transparent\",      # Fifth trace: range for Bananas      \"x[5]\": \"1/Months2\",      \"y[5]\": \"1/bananas\",      \"options[5]\": {\"fill\": \"tozerox\", \"showlegend\": False, \"fillcolor\": \"rgba(0,180,250,0.4)\"},      #      No surrounding stroke      \"color[5]\": \"transparent\",      # Sixth trace: range for Cherries      \"x[6]\": \"1/Months2\",      \"y[6]\": \"1/cherries\",      \"options[6]\": {          \"fill\": \"tozerox\",          \"showlegend\": False,          \"fillcolor\": \"rgba(230,100,120,0.4)\",      },      #      No surrounding stroke      \"color[6]\": \"transparent\",  }    page = \"\"\"  # Continuous Error - Multiple traces    <|{data}|chart|properties={properties}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    from taipy.gui import Gui    # Number of samples  n_samples = 10  # y values: [0..n_samples-1]  y = range(0, n_samples)    data = {      # The x series is made of random numbers between 1 and 10      \"x\": [random.uniform(1, 10) for i in y],      \"y\": y,  }    options = {      \"error_x\": {          \"type\": \"data\",          # Allows for a 'plus' and a 'minus' error data          \"symmetric\": False,          # The 'plus' error data is a series of random numbers          \"array\": [random.uniform(0, 5) for i in y],          # The 'minus' error data is a series of random numbers          \"arrayminus\": [random.uniform(0, 2) for i in y],          # Color of the error bar          \"color\": \"red\",      }  }    page = \"\"\"  # Error bars - Asymmetric    <|{data}|chart|type=bar|x=x|y=y|orientation=h|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import math    from taipy.gui import Gui    # One data point for each degree  theta = range(0, 360)      # Parametric equation that draws a shape (source Wolfram Mathworld)  def draw_heart(angle):      a = math.radians(angle)      sa = math.sin(a)      return 2 - 2 * sa + sa * (math.sqrt(math.fabs(math.cos(a))) / (sa + 1.4))      data = {      # Create the heart shape      \"r\": [draw_heart(angle) for angle in theta],      \"theta\": theta,  }    page = \"\"\"  # Polar - Simple    <|{data}|chart|type=scatterpolar|mode=lines|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # List of countries, used as labels in the pie charts  countries = [\"US\", \"China\", \"European Union\", \"Russian Federation\", \"Brazil\", \"India\", \"Rest of World\"]    data = [      {          # Values for GHG Emissions          \"values\": [16, 15, 12, 6, 5, 4, 42],          \"labels\": countries,      },      {          # Values for CO2 Emissions          \"values\": [27, 11, 25, 8, 1, 3, 25],          \"labels\": countries,      },  ]    options = [      # First pie chart      {          # Show label value on hover          \"hoverinfo\": \"label\",          # Leave a hole in the middle of the chart          \"hole\": 0.4,          # Place the trace on the left side          \"domain\": {\"column\": 0},      },      # Second pie chart      {          # Show label value on hover          \"hoverinfo\": \"label\",          # Leave a hole in the middle of the chart          \"hole\": 0.4,          # Place the trace on the right side          \"domain\": {\"column\": 1},      },  ]    layout = {      # Chart title      \"title\": \"Global Emissions 1990-2011\",      # Show traces in a 1x2 grid      \"grid\": {\"rows\": 1, \"columns\": 2},      \"annotations\": [          # Annotation for the first trace          {              \"text\": \"GHG\",              \"font\": {\"size\": 20},              # Hide annotation arrow              \"showarrow\": False,              # Move to the center of the trace              \"x\": 0.18,              \"y\": 0.5,          },          # Annotation for the second trace          {              \"text\": \"CO2\",              \"font\": {\"size\": 20},              \"showarrow\": False,              # Move to the center of the trace              \"x\": 0.81,              \"y\": 0.5,          },      ],      \"showlegend\": False,  }    page = \"\"\"  # Pie - Multiple    <|{data}|chart|type=pie|x[1]=0/values|x[2]=1/values|options={options}|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # The first data set uses the x interval [-10..10],  # with one point at every other unit  x1_range = [x * 2 for x in range(-5, 6)]    # The second data set uses the x interval [-4..4],  # with ten point between every unit  x2_range = [x / 10 for x in range(-40, 41)]    # Definition of the two data sets  data = [      # Coarse data set      {\"x\": x1_range, \"Coarse\": [x * x for x in x1_range]},      # Fine data set      {\"x\": x2_range, \"Fine\": [x * x for x in x2_range]},  ]    page = \"\"\"  # Advanced - Unbalanced data sets    <|{data}|chart|x[1]=0/x|y[1]=0/Coarse|x[2]=1/x|y[2]=1/Fine|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Flight start and end locations  data = {      # Hartsfield-Jackson Atlanta International Airport      # to      # A\u00e9roport de Paris-Charles de Gaulle      \"lat\": [33.64, 49.01],      \"lon\": [-84.44, 2.55],  }    layout = {      # Chart title      \"title\": \"ATL to CDG\",      # Hide legend      \"showlegend\": False,      # Focus on relevant area      \"geo\": {          \"resolution\": 50,          \"showland\": True,          \"showocean\": True,          \"landcolor\": \"4a4\",          \"oceancolor\": \"77d\",          \"lataxis\": {\"range\": [20, 60]},          \"lonaxis\": {\"range\": [-100, 20]},      },  }    # Flight displayed as a thick, red plot  line = {\"width\": 5, \"color\": \"red\"}    page = \"\"\"  # Maps - Simple    <|{data}|chart|type=scattergeo|mode=lines|lat=lat|lon=lon|line={line}|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    from taipy.gui import Gui    # Random data set  data = {\"Count\": [random.random() for i in range(100)]}    page = \"\"\"  # Histograms - Horizontal    <|{data}|chart|type=histogram|y=Count|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = [      {          \"x\": [1, 2, 3, 4],          \"y\": [10, 11, 12, 13],      },      {          \"x\": [1, 2, 3, 4],          \"y\": [11, 12, 13, 14],      },      {          \"x\": [1, 2, 3, 4],          \"y\": [12, 13, 14, 15],      },  ]    options = [      # First data set is represented by increasingly large      # disks, getting more and more opaque      {\"marker\": {\"color\": \"red\", \"size\": [12, 22, 32, 42], \"opacity\": [0.2, 0.5, 0.7, 1]}},      # Second data set is represented with a different symbol      # for each data point      {          \"marker\": {\"color\": \"blue\", \"size\": 18, \"symbol\": [\"circle\", \"square\", \"diamond\", \"cross\"]},      },      # Third data set is represented with green disks surrounded      # by a red circle that becomes thicker and thicker      {          \"marker\": {\"color\": \"green\", \"size\": 20, \"line\": {\"color\": \"red\", \"width\": [2, 4, 6, 8]}},      },  ]    markers = [      # First data set is represented by increasingly large      # disks, getting more and more opaque      {\"color\": \"red\", \"size\": [12, 22, 32, 42], \"opacity\": [0.2, 0.5, 0.7, 1]},      # Second data set is represented with a different symbol      # for each data point      {\"color\": \"blue\", \"size\": 18, \"symbol\": [\"circle\", \"square\", \"diamond\", \"cross\"]},      # Third data set is represented with green disks surrounded      # by a red circle that becomes thicker and thicker      {\"color\": \"green\", \"size\": 20, \"line\": {\"color\": \"red\", \"width\": [2, 4, 6, 8]}},  ]    layout = {      # Hide the chart legend      \"showlegend\": False,      # Remove all ticks from the x axis      \"xaxis\": {\"showticklabels\": False},      # Remove all ticks from the y axis      \"yaxis\": {\"showticklabels\": False},  }    page = \"\"\"  ## Scatter - Customize markers    <|{data}|chart|mode=markers|layout={layout}|marker={markers}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"Month\": [\"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\", \"Jul\", \"Aug\", \"Sep\", \"Oct\", \"Nov\", \"Dec\"],      \"Milk\": [80, 85, 95, 120, 140, 130, 145, 150, 120, 100, 90, 110],      \"Bread\": [100, 90, 85, 90, 100, 110, 105, 95, 100, 110, 120, 125],      \"Apples\": [50, 65, 70, 65, 70, 75, 85, 70, 60, 65, 70, 80],  }    # Name of the three sets to trace  items = [\"Milk\", \"Bread\", \"Apples\"]    options = {      # Group all traces in the same stack group      \"stackgroup\": \"first_group\"  }    page = \"\"\"  # Filled Area - Stacked    <|{data}|chart|mode=none|x=Month|y={items}|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Data set  data = [      {          # The quarterly periods are grouped by year          \"Period\": [[\"Carry\", \"Q1\", \"Q2\", \"Q3\", \"Q4\", \"Current\"], [\"N-1\", \"N\", \"N\", \"N\", \"N\", \"N+1\"]]      },      {          \"Cash Flow\": [25, -17, 12, 18, -8, None],          \"Measure\": [\"absolute\", \"relative\", \"relative\", \"relative\", \"relative\", \"total\"],      },  ]    page = \"\"\"  # Waterfall - Period levels    <|{data}|chart|type=waterfall|x=0/Period|y=1/Cash Flow|measure=1/Measure|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Major countries and their surface (in km2), for every continent  # Source: https://en.wikipedia.org/wiki/List_of_countries_and_dependencies_by_area  continents = {      \"Africa\": [          {\"name\": \"Algeria\", \"surface\": 2381741},          {\"name\": \"Dem. Rep. Congo\", \"surface\": 2344858},          {\"name\": \"Sudan\", \"surface\": 1886068},          {\"name\": \"Libya\", \"surface\": 1759540},          {\"name\": \"Chad\", \"surface\": 1284000},      ],      \"Asia\": [          {\"name\": \"Russia-Asia\", \"surface\": 17098246},          {\"name\": \"China\", \"surface\": 9596961},          {\"name\": \"India\", \"surface\": 3287263},          {\"name\": \"Kazakhstan\", \"surface\": 2724900},          {\"name\": \"Saudi Arabia\", \"surface\": 2149690},      ],      \"Europe\": [          {\"name\": \"Russia-Eur\", \"surface\": 3972400},          {\"name\": \"Ukraine\", \"surface\": 603628},          {\"name\": \"France\", \"surface\": 551695},          {\"name\": \"Spain\", \"surface\": 498980},          {\"name\": \"Sweden\", \"surface\": 450295},      ],      \"Americas\": [          {\"name\": \"Canada\", \"surface\": 9984670},          {\"name\": \"U.S.A.\", \"surface\": 9833517},          {\"name\": \"Brazil\", \"surface\": 8515767},          {\"name\": \"Argentina\", \"surface\": 2780400},          {\"name\": \"Mexico\", \"surface\": 1964375},      ],      \"Oceania\": [          {\"name\": \"Australia\", \"surface\": 7692024},          {\"name\": \"Papua New Guinea\", \"surface\": 462840},          {\"name\": \"New Zealand\", \"surface\": 270467},          {\"name\": \"Solomon Islands\", \"surface\": 28896},          {\"name\": \"Fiji\", \"surface\": 18274},      ],      \"Antarctica\": [{\"name\": \"Whole\", \"surface\": 14200000}],  }    name = []  surface = []  continent = []    for continent_name, countries in continents.items():      # Create continent in root rectangle      name.append(continent_name)      surface.append(0)      continent.append(\"\")      # Create countries in that continent rectangle      for country in countries:          name.append(country[\"name\"])          surface.append(country[\"surface\"])          continent.append(continent_name)    data = {\"names\": name, \"surfaces\": surface, \"continent\": continent}    page = \"\"\"  # TreeMap - Hierarchical values    <|{data}|chart|type=treemap|labels=names|values=surfaces|parents=continent|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import datetime    from taipy.gui import Gui    # Retrieved history:  # (Open, Close, Low, High)  stock_history = [      (311.05, 311.00, 310.75, 311.33),      (308.53, 308.31, 307.72, 309.00),      (307.35, 306.24, 306.12, 307.46),      (306.35, 304.90, 304.34, 310.10),      (304.90, 302.99, 302.27, 307.00),      (303.03, 301.66, 301.20, 303.25),      (301.61, 299.58, 299.50, 301.89),      (299.58, 297.95, 297.80, 300.06),      (297.95, 299.03, 297.14, 299.67),      (299.03, 301.87, 296.71, 301.89),      (301.89, 299.40, 298.73, 302.93),      (299.50, 299.35, 298.83, 299.50),      (299.35, 299.20, 299.19, 299.68),      (299.42, 300.50, 299.42, 300.50),      (300.70, 300.65, 300.32, 300.75),      (300.65, 299.91, 299.91, 300.76),  ]  start_date = datetime.datetime(year=2022, month=10, day=21)  period = datetime.timedelta(seconds=4 * 60 * 60)  # 4 hours    data = {      # Compute date series      \"Date\": [start_date + n * period for n in range(0, len(stock_history))],      # Extract open values      \"Open\": [v[0] for v in stock_history],      # Extract close values      \"Close\": [v[1] for v in stock_history],      # Extract low values      \"Low\": [v[2] for v in stock_history],      # Extract high values      \"High\": [v[3] for v in stock_history],  }    md = \"\"\"  # Candlestick - Timeline    <|{data}|chart|type=candlestick|x=Date|open=Open|close=Close|low=Low|high=High|>  \"\"\"    Gui(md).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"John_us\": [500, 450, 340, 230, 220, 110],      \"John_eu\": [600, 500, 400, 300, 200, 100],      \"Robert_us\": [510, 480, 440, 330, 220, 100],      \"Robert_eu\": [360, 250, 240, 130, 120, 60],  }    # Values for each trace  values = [\"John_us\", \"John_eu\", \"Robert_us\", \"Robert_eu\"]    options = [      # For John/US      {          \"scalegroup\": \"first\",          \"textinfo\": \"value\",          \"title\": {              # \"position\": \"top\",              \"text\": \"John in the U.S.\"          },          # Lower-left corner          \"domain\": {\"x\": [0, 0.5], \"y\": [0, 0.5]},      },      # For John/EU      {          \"scalegroup\": \"first\",          \"textinfo\": \"value\",          \"title\": {              # \"position\": \"top\",              \"text\": \"John in the E.U.\"          },          # Upper-left corner          \"domain\": {\"x\": [0, 0.5], \"y\": [0.55, 1]},      },      # For Robert/US      {          \"scalegroup\": \"second\",          \"textinfo\": \"value\",          \"title\": {              # \"position\": \"top\",              \"text\": \"Robert in the U.S.\"          },          # Lower-right corner          \"domain\": {\"x\": [0.51, 1], \"y\": [0, 0.5]},      },      # For Robert/EU      {          \"scalegroup\": \"second\",          \"textinfo\": \"value\",          \"title\": {              # \"position\": \"top\",              \"text\": \"Robert in the E.U.\"          },          # Upper-right corner          \"domain\": {\"x\": [0.51, 1], \"y\": [0.51, 1]},      },  ]    layout = {      \"title\": \"Sales per Salesman per Region\",      \"showlegend\": False,      # Draw frames around each trace      \"shapes\": [          {\"x0\": 0, \"x1\": 0.5, \"y0\": 0, \"y1\": 0.5},          {\"x0\": 0, \"x1\": 0.5, \"y0\": 0.52, \"y1\": 1},          {\"x0\": 0.52, \"x1\": 1, \"y0\": 0, \"y1\": 0.5},          {\"x0\": 0.52, \"x1\": 1, \"y0\": 0.52, \"y1\": 1},      ],  }    page = \"\"\"  # Funnel Area - Multiple Charts    <|{data}|chart|type=funnelarea|values={values}|options={options}|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import math    from taipy.gui import Gui    # One data point for each degree  theta = range(0, 360)      # Parametric equation that draws a shape (source Wolfram Mathworld)  def draw_heart(angle):      a = math.radians(angle)      sa = math.sin(a)      return 2 - 2 * sa + sa * (math.sqrt(math.fabs(math.cos(a))) / (sa + 1.4))      data = {      # Create the heart shape      \"r\": [draw_heart(angle) for angle in theta],      \"theta\": theta,  }    options = {\"fill\": \"toself\"}    layout = {      # Hide the legend      \"showlegend\": False,      \"polar\": {          # Hide the angular axis          \"angularaxis\": {\"visible\": False},          # Hide the radial axis          \"radialaxis\": {\"visible\": False},      },  }    page = \"\"\"  # Polar - Area    <|{data}|chart|type=scatterpolar|mode=none|layout={layout}|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Partial family tree of the British House of Windsor  # Source: https://en.wikipedia.org/wiki/Family_tree_of_the_British_royal_family  tree = {      \"name\": [          \"Queen Victoria\",          \"Princess Victoria\",          \"Edward VII\",          \"Alice\",          \"Alfred\",          \"Wilhelm II\",          \"Albert Victor\",          \"George V\",          \"Louise\",          \"Ernest Louis\",          \"Alfred (2)\",          \"Marie\",          \"Victoria Melita\",          \"Edward VIII\",          \"George VI\",          \"Mary\",          \"Elizabeth II\",          \"Margaret\",          \"Charles III\",          \"Anne\",          \"Andrew\",      ],      \"parent\": [          \"\",          \"Queen Victoria\",          \"Queen Victoria\",          \"Queen Victoria\",          \"Queen Victoria\",          \"Princess Victoria\",          \"Edward VII\",          \"Edward VII\",          \"Edward VII\",          \"Alice\",          \"Alfred\",          \"Alfred\",          \"Alfred\",          \"George V\",          \"George V\",          \"George V\",          \"George VI\",          \"George VI\",          \"Elizabeth II\",          \"Elizabeth II\",          \"Elizabeth II\",      ],  }    page = \"\"\"  # TreeMap - Hierarchical    <|{tree}|chart|type=treemap|labels=name|parents=parent|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # You may need to install the scikit-learn package as well.  # -----------------------------------------------------------------------------------------  import numpy as np  import pandas as pd  from sklearn.datasets import make_classification    from taipy.gui import Gui    # Let scikit-learn generate a random 2-class classification problem  n_samples = 100  features, label = make_classification(n_samples=n_samples, n_features=2, n_informative=2, n_redundant=0)    random_data = pd.DataFrame({\"x\": features[:, 0], \"y\": features[:, 1], \"label\": label})    data_x = random_data[\"x\"]  class_A = [random_data.loc[i, \"y\"] if random_data.loc[i, \"label\"] == 0 else np.nan for i in range(n_samples)]  class_B = [random_data.loc[i, \"y\"] if random_data.loc[i, \"label\"] == 1 else np.nan for i in range(n_samples)]    data = {\"x\": random_data[\"x\"], \"Class A\": class_A, \"Class B\": class_B}  marker_A = {\"symbol\": \"circle-open\", \"size\": 16}  marker_B = {\"symbol\": \"triangle-up-dot\", \"size\": 20, \"opacity\": 0.7}  page = \"\"\"  # Scatter - Styling    <|{data}|chart|mode=markers|x=x|y[1]=Class A|y[2]=Class B|width=60%|marker[1]={marker_A}|marker[2]={marker_B}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"Temperatures\": [          [17.2, 27.4, 28.6, 21.5],          [5.6, 15.1, 20.2, 8.1],          [26.6, 22.8, 21.8, 24.0],          [22.3, 15.5, 13.4, 19.6],      ],      \"Cities\": [\"Hanoi\", \"Paris\", \"Rio\", \"Sydney\"],      \"Seasons\": [\"Winter\", \"Spring\", \"Summer\", \"Autumn\"],  }    options = {\"colorscale\": \"Portland\"}    page = \"\"\"  # Heatmap - Colorscale    <|{data}|chart|type=heatmap|z=Temperatures|x=Seasons|y=Cities|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    layout = {      \"xaxis\": {          # Force the title of the x axis          \"title\": \"Values for x\"      }  }    page = \"\"\"  # Basics - Title    <|{[x*x for x in range(0, 11)]}|chart|title=Plotting x squared|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Data set: the first 10 elements of the Fibonacci sequence  n_numbers = 10  fibonacci = [0, 1]  for i in range(2, n_numbers):      fibonacci.append(fibonacci[i - 1] + fibonacci[i - 2])    data = {\"index\": [i for i in range(1, n_numbers + 1)], \"fibonacci\": fibonacci}    page = \"\"\"  # TreeMap - Simple    <|{data}|chart|type=treemap|labels=index|values=fibonacci|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy import Gui    # The chart control's data is defined as inline  # code.  page = \"\"\"  # Basics - Simple line    <|{[x*x for x in range(0, 11)]}|chart|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    from taipy import Gui    # Random data set  data = [random.gauss(0, 5) for i in range(1000)]    page = \"\"\"  # Histogram - Simple    <|{data}|chart|type=histogram|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import pandas    from taipy.gui import Gui    # Source https://en.wikipedia.org/wiki/List_of_United_States_presidential_elections_by_popular_vote_margin  percentages = [      (1852, 50.83),      (1856, 45.29),      (1860, 39.65),      (1864, 55.03),      (1868, 52.66),      (1872, 55.58),      (1876, 47.92),      (1880, 48.31),      (1884, 48.85),      (1888, 47.80),      (1892, 46.02),      (1896.0, 51.02),      (1900, 51.64),      (1904, 56.42),      (1908, 51.57),      (1912, 41.84),      (1916, 49.24),      (1920, 60.32),      (1924, 54.04),      (1928, 58.21),      (1932, 57.41),      (1936, 60.80),      (1940, 54.74),      (1944, 53.39),      (1948, 49.55),      (1952, 55.18),      (1956, 57.37),      (1960, 49.72),      (1964, 61.05),      (1968, 43.42),      (1972, 60.67),      (1976, 50.08),      (1980, 50.75),      (1984, 58.77),      (1988, 53.37),      (1992, 43.01),      (1996, 49.23),      (2000, 47.87),      (2004, 50.73),      (2008, 52.93),      (2012, 51.06),      (2016, 46.09),      (2020, 51.31),  ]  data = pandas.DataFrame(percentages, columns=[\"Year\", \"%\"])    page = \"\"\"  # Bar - Simple    <|{data}|chart|type=bar|x=Year|y=%|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    from taipy.gui import Gui    # Random set of 100 samples  samples = {\"x\": [random.gauss() for i in range(100)]}    # Use the same data for both traces  data = [samples, samples]    options = [      # First data set displayed as green-ish, and 5 bins      {\"marker\": {\"color\": \"#4A4\"}, \"nbinsx\": 5},      # Second data set displayed as red-ish, and 25 bins      {\"marker\": {\"color\": \"#A33\"}, \"nbinsx\": 25},  ]    layout = {      # Overlay the two histograms      \"barmode\": \"overlay\",      # Hide the legend      \"showlegend\": False,  }    page = \"\"\"  # Histogram - NBins    <|{data}|chart|type=histogram|options={options}|layout={layout}|>  \"\"\"  Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Data set  data = {\"Opps\": [\"Hot leads\", \"Doc sent\", \"Quote\", \"Closed Won\"], \"Visits\": [316, 238, 125, 83]}    page = \"\"\"  # Funnel Chart - Simple    <|{data}|chart|type=funnel|x=Visits|y=Opps|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = [      {          \"Temperatures\": [              [17.2, 27.4, 28.6, 21.5],              [5.6, 15.1, 20.2, 8.1],              [26.6, 22.8, 21.8, 24.0],              [22.3, 15.5, 13.4, 19.6],              [3.9, 18.9, 25.7, 9.8],          ],          \"Cities\": [\"Hanoi\", \"Paris\", \"Rio\", \"Sydney\", \"Washington\"],      },      {\"Seasons\": [\"Winter\", \"Spring\", \"Summer\", \"Autumn\"]},  ]    page = \"\"\"  # Heatmap - Unbalanced    <|{data}|chart|type=heatmap|z=0/Temperatures|x=1/Seasons|y=0/Cities|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Sample small plot definition  trace = {      \"r\": [1, 2, 3, 4, 1],      \"theta\": [0, 40, 80, 120, 160],  }    # The same data is used in both traces  data = [trace, trace]    # Naming the subplot is mandatory to get them both in  # the same chart  options = [      {          \"subplot\": \"polar\",      },      {\"subplot\": \"polar2\"},  ]    layout = {      # Hide the legend      \"showlegend\": False,      # Restrict the angular values for second trace      \"polar2\": {\"sector\": [30, 130]},  }    md = \"\"\"  # Polar - Sectors    <|{data}|chart|type=scatterpolar|layout={layout}|options={options}|>  \"\"\"    Gui(md).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # You may need to install the yfinance package as well.  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"x\": [1, 2, 3],      \"y\": [1, 2, 3],      \"Colors\": [\"blue\", \"green\", \"red\"],      \"Sizes\": [20, 40, 30],      \"Opacities\": [1, 0.4, 1],  }    marker = {\"color\": \"Colors\", \"size\": \"Sizes\", \"opacity\": \"Opacities\"}    page = \"\"\"  # Bubble - Simple    <|{data}|chart|mode=markers|x=x|y=y|marker={marker}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Source: www.statista.com (Most used programming languages in 2022)  data = {      # List of programming languages      \"Language\": [\"JavaScript\", \"HTML/CSS\", \"SQL\", \"Python\", \"Typescript\", \"Java\", \"Bash/Shell\"],      # Percentage of usage, per language      \"%\": [65.36, 55.08, 49.43, 48.07, 34.83, 33.27, 29.07],  }    # Close the shape for a nice-looking stroke  # If the first point is *not* appended to the end of the list,  # then the shape does not look as it is closed.  data[\"%\"].append(data[\"%\"][0])  data[\"Language\"].append(data[\"Language\"][0])    layout = {      \"polar\": {          \"radialaxis\": {              # Force the radial range to 0-100              \"range\": [0, 100],          }      },      # Hide legend      \"showlegend\": False,  }    options = {      # Fill the trace      \"fill\": \"toself\"  }    md = \"\"\"  # Radar - Simple    <|{data}|chart|type=scatterpolar|r=%|theta=Language|options={options}|layout={layout}|>  \"\"\"    Gui(md).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Initial data set. y = count_of(x)  samples = {\"x\": [\"Apples\", \"Apples\", \"Apples\", \"Oranges\", \"Bananas\", \"Oranges\"], \"y\": [5, 10, 3, 8, 5, 2]}    # Create a data set array to allow for two traces  data = [samples, samples]    # Gather those settings in a single dictionary  properties = {      # 'x' of the first trace is the 'x' data from the first element of data      \"x[1]\": \"0/x\",      # 'y' of the first trace is the 'y' data from the first element of data      \"y[1]\": \"0/y\",      # 'x' of the second trace is the 'x' data from the second element of data      \"x[2]\": \"1/x\",      # 'y' of the second trace is the 'y' data from the second element of data      \"y[2]\": \"1/y\",      # Data set colors      \"color\": [\"#cd5c5c\", \"#505070\"],      # Data set names (for the legend)      \"name\": [\"Count\", \"Sum\"],      # Configure the binning functions      \"options\": [          # First trace: count the bins          {\"histfunc\": \"count\"},          # Second trace: sum the bin occurences          {\"histfunc\": \"sum\"},      ],      # Set x axis name      \"layout\": {\"xaxis\": {\"title\": \"Fruit\"}},  }    page = \"\"\"  # Histogram - Binning function    <|{data}|chart|type=histogram|properties={properties}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Skill categories  skills = [\"HTML\", \"CSS\", \"Java\", \"Python\", \"PHP\", \"JavaScript\", \"Photoshop\"]  data = [      # Proportion of skills used for Backend development      {\"Backend\": [10, 10, 80, 70, 90, 30, 0], \"Skills\": skills},      # Proportion of skills used for Frontend development      {\"Frontend\": [90, 90, 0, 10, 20, 80, 60], \"Skills\": skills},  ]    # Append first elements to all arrays for a nice stroke  skills.append(skills[0])  data[0][\"Backend\"].append(data[0][\"Backend\"][0])  data[1][\"Frontend\"].append(data[1][\"Frontend\"][0])    layout = {      # Force the radial axis displayed range      \"polar\": {\"radialaxis\": {\"range\": [0, 100]}}  }    # Fill the trace  options = {\"fill\": \"toself\"}    # Reflected in the legend  names = [\"Backend\", \"Frontend\"]    # To shorten the chart control definition  r = [\"0/Backend\", \"1/Frontend\"]  theta = [\"0/Skills\", \"1/Skills\"]    page = \"\"\"  # Radar - Multiple    <|{data}|chart|type=scatterpolar|name={names}|r={r}|theta={theta}|options={options}|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # x values are [-10..10]  x_range = range(-10, 11)    # The data set holds the _x_ series and two distinct series for _y_  data = {      \"x\": x_range,      # y1 = x*x      \"y1\": [x * x for x in x_range],      # y2 = 2-x*x/50      \"y2\": [(100 - x * x) / 50 for x in x_range],  }    layout = {      \"yaxis2\": {          # Second axis overlays with the first y axis          \"overlaying\": \"y\",          # Place the second axis on the right          \"side\": \"right\",          # and give it a title          \"title\": \"Second y axis\",      },      \"legend\": {          # Place the legend above chart          \"yanchor\": \"bottom\"      },  }    page = \"\"\"  # Basics - Multiple axis    Shared axis:  <|{data}|chart|x=x|y[1]=y1|y[2]=y2|height=300px|>    With two axis:  <|{data}|chart|x=x|y[1]=y1|y[2]=y2|yaxis[2]=y2|layout={layout}|height=300px|>    \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Source https://www.fao.org/faostat/en/#data/SDGB  data = {      \"Country\": [          \"Rest of the world\",          \"Russian Federation\",          \"Brazil\",          \"Canada\",          \"United States of America\",          \"China\",          \"Australia\",          \"Democratic Republic of the Congo\",          \"Indonesia\",          \"Peru\",      ],      \"Area\": [1445674.66, 815312, 496620, 346928, 309795, 219978, 134005, 126155, 92133.2, 72330.4],  }    page = \"\"\"  # Pie - Simple    <|{data}|chart|type=pie|values=Area|label=Country|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # You may need to install the scikit-learn package as well.  # -----------------------------------------------------------------------------------------  from os.path import exists    from sklearn.datasets import make_regression  from sklearn.linear_model import LinearRegression    from taipy.gui import Gui    # Let scikit-learn generate a random regression problem  n_samples = 300  X, y, coef = make_regression(n_samples=n_samples, n_features=1, n_informative=1, n_targets=1, noise=25, coef=True)    model = LinearRegression().fit(X, y)    x_data = X.flatten()  y_data = y.flatten()  predict = model.predict(X)    data = {\"x\": x_data, \"y\": y_data, \"Regression\": predict}    page = \"\"\"  # Scatter - Regression    <|{data}|chart|x=x|y[1]=y|mode[1]=markers|y[2]=Regression|mode[2]=line|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"x\": [1, 2, 3],      \"y\": [1, 2, 3],      \"Texts\": [\"Blue<br>Small\", \"Green<br>Medium\", \"Red<br>Large\"],      \"Sizes\": [60, 80, 100],      \"Colors\": [          \"rgb(93, 164, 214)\",          \"rgb(44, 160, 101)\",          \"rgb(255, 65, 54)\",      ],  }    marker = {\"size\": \"Sizes\", \"color\": \"Colors\"}    page = \"\"\"  # Bubble - Hover text    <|{data}|chart|mode=markers|x=x|y=y|marker={marker}|text=Texts|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"Temperatures\": [          [17.2, 27.4, 28.6, 21.5],          [5.6, 15.1, 20.2, 8.1],          [26.6, 22.8, 21.8, 24.0],          [22.3, 15.5, 13.4, 19.6],      ],      \"Cities\": [\"Hanoi\", \"Paris\", \"Rio\", \"Sydney\"],      \"Seasons\": [\"Winter\", \"Spring\", \"Summer\", \"Autumn\"],  }    layout = {      # This array contains the information we want to display in the cells      # These are filled later      \"annotations\": [],      # No ticks on the x axis, show labels on top the of the chart      \"xaxis\": {\"ticks\": \"\", \"side\": \"top\"},      # No ticks on the y axis      # Add a space character for a small margin with the text      \"yaxis\": {\"ticks\": \"\", \"ticksuffix\": \" \"},  }    seasons = data[\"Seasons\"]  cities = data[\"Cities\"]  # Iterate over all cities  for city in range(len(cities)):      # Iterate over all seasons      for season in range(len(seasons)):          temperature = data[\"Temperatures\"][city][season]          # Create the annotation          annotation = {              # The name of the season              \"x\": seasons[season],              # The name of the city              \"y\": cities[city],              # The temperature, as a formatted string              \"text\": f\"{temperature}\\N{DEGREE SIGN}C\",              # Change the text color depending on the temperature              # so it results in a better contrast              \"font\": {\"color\": \"white\" if temperature < 14 else \"black\"},              # Remove the annotation arrow              \"showarrow\": False,          }          # Add the annotation to the layout's annotations array          layout[\"annotations\"].append(annotation)    page = \"\"\"  ## Heatmap - Annotated    <|{data}|chart|type=heatmap|z=Temperatures|x=Seasons|y=Cities|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui      # Function to plot: x^3/3 - x  def f(x):      return x * x * x / 3 - x      # x values: [-2.2, ..., 2.2]  x = [(x - 10) / 4.5 for x in range(0, 21)]    data = {      \"x\": x,      # y: [f(-2.2), ..., f(2.2)]      \"y\": [f(x) for x in x],  }      layout = {      # Chart title      \"title\": \"Local extrema\",      \"annotations\": [          # Annotation for local maximum (x = -1)          {\"text\": \"Local <b>max</b>\", \"font\": {\"size\": 20}, \"x\": -1, \"y\": f(-1)},          # Annotation for local minimum (x = 1)          {\"text\": \"Local <b>min</b>\", \"font\": {\"size\": 20}, \"x\": 1, \"y\": f(1), \"xanchor\": \"left\"},      ],  }    page = \"\"\"  # Advanced - Annotations    <|{data}|chart|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"Types\": [\"Website visit\", \"Downloads\", \"Prospects\", \"Invoice sent\", \"Closed\"],      \"Visits_us\": [13873, 10533, 5443, 2703, 908],      \"Visits_eu\": [7063, 4533, 3443, 1003, 1208],      \"Visits_ap\": [6873, 2533, 3443, 1703, 508],  }    # Columns for each trace  x = [\"Visits_us\", \"Visits_eu\", \"Visits_ap\"]    # Legend text for each trace  names = [\"US\", \"EU\", \"AP\"]    page = \"\"\"  # Funnel - Multiple traces    <|{data}|chart|type=funnel|x={x}|y=Types|name={names}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"Temperatures\": [          [17.2, 27.4, 28.6, 21.5],          [5.6, 15.1, 20.2, 8.1],          [26.6, 22.8, 21.8, 24.0],          [22.3, 15.5, 13.4, 19.6],      ],      \"Cities\": [\"Hanoi\", \"Paris\", \"Rio\", \"Sydney\"],      \"Seasons\": [\"Winter\", \"Spring\", \"Summer\", \"Autumn\"],  }    page = \"\"\"  # Heatmap - Basic    <|{data}|chart|type=heatmap|z=Temperatures|x=Seasons|y=Cities|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  # Face-to-face bar charts example  import numpy    from taipy.gui import Gui    n_years = 10    proportions_female = numpy.zeros(n_years)  proportions_male = numpy.zeros(n_years)    # Prepare the data set with random variations  proportions_female[0] = 0.4  proportions_male[0] = proportions_female[0] * (1 + numpy.random.normal(0, 0.1))    for i in range(1, n_years):      mean_i = (0.5 - proportions_female[i - 1]) / 5      new_value = proportions_female[i - 1] + numpy.random.normal(mean_i, 0.1)        new_value = min(max(0, new_value), 1)      proportions_female[i] = new_value      proportions_male[i] = proportions_female[i] * (1 + numpy.random.normal(0, 0.1))      data = {      \"Hobbies\": [          \"Archery\",          \"Tennis\",          \"Football\",          \"Basket\",          \"Volley\",          \"Golf\",          \"Video-Games\",          \"Reading\",          \"Singing\",          \"Music\",      ],      \"Female\": proportions_female,      # Negate these values so they appear to the left side      \"Male\": -proportions_male,  }    properties = {      # Shared y values      \"y\": \"Hobbies\",      # Bars for the female data set      \"x[1]\": \"Female\",      \"color[1]\": \"#c26391\",      # Bars for the male data set      \"x[2]\": \"Male\",      \"color[2]\": \"#5c91de\",      # Both data sets are represented with an horizontal orientation      \"orientation\": \"h\",      #      \"layout\": {          # This makes left and right bars aligned on the same y value          \"barmode\": \"overlay\",          # Set a relevant title for the x axis          \"xaxis\": {\"title\": \"Gender\"},          # Hide the legend          \"showlegend\": False,          \"margin\": {\"l\": 100},      },  }    page = \"\"\"  # Bar - Facing    <|{data}|chart|type=bar|properties={properties}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    from taipy.gui import Gui    # Random data set  data = [random.random() for i in range(100)]    # Normalize to show bin probabilities  options = {\"histnorm\": \"probability\"}    page = \"\"\"  # Histogram - Normalized    <|{data}|chart|type=histogram|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # You may need to install the scikit-learn package as well.  # -----------------------------------------------------------------------------------------  import numpy  import pandas  from sklearn.datasets import make_classification    from taipy.gui import Gui    # Let scikit-learn generate a random 2-class classification problem  features, label = make_classification(n_samples=1000, n_features=2, n_informative=2, n_redundant=0)    random_data = pandas.DataFrame({\"x\": features[:, 0], \"y\": features[:, 1], \"label\": label})    data_x = random_data[\"x\"]  class_A = [random_data.loc[i, \"y\"] if random_data.loc[i, \"label\"] == 0 else numpy.nan for i in range(len(random_data))]  class_B = [random_data.loc[i, \"y\"] if random_data.loc[i, \"label\"] == 1 else numpy.nan for i in range(len(random_data))]    data = {\"x\": random_data[\"x\"], \"Class A\": class_A, \"Class B\": class_B}    page = \"\"\"  # Scatter - Classification    <|{data}|chart|mode=markers|x=x|y[1]=Class A|y[2]=Class B|width=60%|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from itertools import accumulate    import numpy as np    from taipy.gui import Gui    grid_size = 10  data = [      {          # z is set to:          # - 0 if row+col is a multiple of 4          # - 1 if row+col is a multiple of 2          # - 0.5 otherwise          \"z\": [              [0.0 if (row + col) % 4 == 0 else 1 if (row + col) % 2 == 0 else 0.5 for col in range(grid_size)]              for row in range(grid_size)          ]      },      {          # A series of coordinates, growing exponentially          \"x\": [0] + list(accumulate(np.logspace(0, 1, grid_size))),          # A series of coordinates, shrinking exponentially          \"y\": [0] + list(accumulate(np.logspace(1, 0, grid_size))),      },  ]    # Axis template used in the layout object  axis_template = {      # Don't show any line or tick or label      \"showgrid\": False,      \"zeroline\": False,      \"ticks\": \"\",      \"showticklabels\": False,      \"visible\": False,  }    layout = {\"xaxis\": axis_template, \"yaxis\": axis_template}    options = {      # Remove the color scale display      \"showscale\": False  }    page = \"\"\"  ## Heatmap - Unequal block sizes    <|{data}|chart|type=heatmap|z=0/z|x=1/x|y=1/y|layout={layout}|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # 9-hole course  n_holes = 9    # Data set  # Each entry holds an array of values. One for each hole, plus one for th  data = {      # [\"Hole1\", \"Hole2\", ..., \"Hole9\"]      \"Hole\": [f\"Hole{h}\" for h in range(1, n_holes + 1)] + [\"Score\"],      # Par for each hole      \"Par\": [3, 4, 4, 5, 3, 5, 4, 5, 3] + [None],      # Score for each hole      \"Score\": [4, 4, 5, 4, 4, 5, 4, 5, 4] + [None],      # Represented as relative values except for the last one      \"M\": n_holes * [\"relative\"] + [\"total\"],  }    # Compute difference (Score-Par)  data[\"Diff\"] = [data[\"Score\"][i] - data[\"Par\"][i] for i in range(0, n_holes)] + [None]    # Show positive values in red, and negative values in green  options = {\"decreasing\": {\"marker\": {\"color\": \"green\"}}, \"increasing\": {\"marker\": {\"color\": \"red\"}}}    page = \"\"\"  # Waterfall - Styling    <|{data}|chart|type=waterfall|x=Hole|y=Diff|measure=M|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    from taipy.gui import Gui    # Common axis for all data: [1..10]  x = list(range(1, 11))  # Sample data  samples = [5, 7, 8, 4, 5, 9, 8, 8, 6, 5]    # Generate error data  # Error that adds to the input data  error_plus = [3 * random.random() + 0.5 for _ in x]  # Error substracted from to the input data  error_minus = [3 * random.random() + 0.5 for _ in x]    # Upper bound (y + error_plus)  error_upper = [y + e for (y, e) in zip(samples, error_plus)]  # Lower bound (y - error_minus)  error_lower = [y - e for (y, e) in zip(samples, error_minus)]    data = [      # Trace for samples      {\"x\": x, \"y\": samples},      # Trace for error range      {          # Roundtrip around the error bounds: onward then return          \"x\": x + list(reversed(x)),          # The two error bounds, with lower bound reversed          \"y\": error_upper + list(reversed(error_lower)),      },  ]    properties = {      # Error data      \"x[1]\": \"1/x\",      \"y[1]\": \"1/y\",      \"options[1]\": {          # Shows as filled area          \"fill\": \"toself\",          \"fillcolor\": \"rgba(70,70,240,0.6)\",          \"showlegend\": False,      },      # Don't show surrounding stroke      \"color[1]\": \"transparent\",      # Raw data (displayed on top of the error band)      \"x[2]\": \"0/x\",      \"y[2]\": \"0/y\",      \"color[2]\": \"rgb(140,50,50)\",      # Shown in the legend      \"name[2]\": \"Input\",  }    page = \"\"\"  # Continuous Error - Simple    <|{data}|chart|properties={properties}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"Products\": [          \"Nail polish\",          \"Eyebrow pencil\",          \"Rouge\",          \"Lipstick\",          \"Eyeshadows\",          \"Eyeliner\",          \"Foundation\",          \"Lip gloss\",          \"Mascara\",      ],      \"USA\": [12814, 13012, 11624, 8814, 12998, 12321, 10342, 22998, 11261],      \"China\": [3054, 5067, 7004, 9054, 12043, 15067, 10119, 12043, 10419],      \"EU\": [4376, 3987, 3574, 4376, 4572, 3417, 5231, 4572, 6134],      \"Africa\": [4229, 3932, 5221, 9256, 3308, 5432, 13701, 4008, 18712],  }    # Order the different traces  ys = [\"USA\", \"China\", \"EU\", \"Africa\"]    options = [      # For the USA      {\"stackgroup\": \"one\", \"groupnorm\": \"percent\"},      # For China      {\"stackgroup\": \"one\"},      # For the EU      {\"stackgroup\": \"one\"},      # For Africa      {\"stackgroup\": \"one\"},  ]    layout = {      # Show all values when hovering on a data point      \"hovermode\": \"x unified\"  }    page = \"\"\"  # Filled Area - Stacked Normalized    <|{data}|chart|mode=none|x=Products|y={ys}|options={options}|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import math    from taipy.gui import Gui    # One data point for each degree  theta = range(0, 360)      # Create a rose-like shaped radius-array  def create_rose(n_petals):      return [math.cos(math.radians(n_petals * angle)) for angle in theta]      data = {\"theta\": theta, \"r1\": create_rose(2), \"r2\": create_rose(3), \"r3\": create_rose(4)}    # We want three traces in the same chart  r = [\"r1\", \"r2\", \"r3\"]    layout = {      # Hide the legend      \"showlegend\": False,      \"polar\": {          # Hide the angular axis          \"angularaxis\": {\"visible\": False},          # Hide the radial axis          \"radialaxis\": {\"visible\": False},      },  }    page = \"\"\"  # Polar - Multiple    <|{data}|chart|type=scatterpolar|mode=lines|r={r}|theta=theta|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # You may need to install the yfinance package as well.  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"x\": [1, 2, 3, 4, 5],      \"y\": [10, 7, 4, 1, 5],      \"Sizes\": [20, 30, 40, 50, 30],      \"Symbols\": [\"circle-open\", \"triangle-up\", \"hexagram\", \"star-diamond\", \"circle-cross\"],  }    marker = {      \"color\": \"#77A\",      \"size\": \"Sizes\",      \"symbol\": \"Symbols\",  }    page = \"\"\"  # Bubble - Symbols    <|{data}|chart|mode=markers|x=x|y=y|marker={marker}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # You may need to install the yfinance package as well.  # -----------------------------------------------------------------------------------------  import yfinance    from taipy.gui import Gui    # Extraction of a few days of stock historical data for AAPL using  # the yfinance package (see https://pypi.org/project/yfinance/).  # The returned value is a Pandas DataFrame.  ticker = yfinance.Ticker(\"AAPL\")  stock = ticker.history(interval=\"1d\", start=\"2018-08-18\", end=\"2018-09-10\")  # Copy the DataFrame index to a new column  stock[\"Date\"] = stock.index    options = {      # Candlesticks that show decreasing values are orange      \"decreasing\": {\"line\": {\"color\": \"orange\"}},      # Candlesticks that show decreasing values are blue      \"increasing\": {\"line\": {\"color\": \"blue\"}},  }    layout = {      \"xaxis\": {          # Hide the range slider          \"rangeslider\": {\"visible\": False}      }  }    page = \"\"\"  # Candlestick - Styling    <|{stock}|chart|type=candlestick|x=Date|open=Open|close=Close|low=Low|high=High|options={options}|layout={layout}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    data = {      \"Types\": [\"Website visit\", \"Downloads\", \"Prospects\", \"Invoice sent\", \"Closed\"],      \"Visits\": [13873, 10533, 5443, 2703, 908],  }    marker = {      # Boxes are filled with a blue gradient color      \"color\": [\"hsl(210,50%,50%)\", \"hsl(210,60%,60%)\", \"hsl(210,70%,70%)\", \"hsl(210,80%,80%)\", \"hsl(210,90%,90%)\"],      # Lines get thicker, with an orange-to-green gradient color      \"line\": {\"width\": [1, 1, 2, 3, 4], \"color\": [\"f5720a\", \"f39c1d\", \"f0cc3d\", \"aadb12\", \"8cb709\"]},  }    options = {      # Lines connecting boxes are thick, dotted and green      \"connector\": {\"line\": {\"color\": \"green\", \"dash\": \"dot\", \"width\": 4}}  }    page = \"\"\"  # Funnel Chart - Custom markers    <|{data}|chart|type=funnel|x=Visits|y=Types|marker={marker}|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import random    from taipy.gui import Gui    # Random data set  data = [random.random() for i in range(500)]    options = {      # Enable the cumulative histogram      \"cumulative\": {\"enabled\": True}  }    page = \"\"\"  # Histogram - Cumulative    <|{data}|chart|type=histogram|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Create a star shape  data = {\"r\": [3, 1] * 5 + [3], \"theta\": list(range(0, 360, 36)) + [0]}    options = [      # First plot is filled with a yellow-ish color      {\"subplot\": \"polar\", \"fill\": \"toself\", \"fillcolor\": \"#E4FF87\"},      # Second plot is filled with a blue-ish color      {\"fill\": \"toself\", \"subplot\": \"polar2\", \"fillcolor\": \"#709BFF\"},  ]    layout = {      \"polar\": {          # This actually is the default value          \"angularaxis\": {              \"direction\": \"counterclockwise\",          },      },      \"polar2\": {          \"angularaxis\": {              # Rotate the axis 180\u00b0 (0 is on the left)              \"rotation\": 180,              # Orient the axis clockwise              \"direction\": \"clockwise\",              # Show the angles as radians              \"thetaunit\": \"radians\",          },      },      # Hide the legend      \"showlegend\": False,  }    page = \"\"\"  # Polar Charts - Direction    <|{data}|chart|type=scatterpolar|layout={layout}|options={options}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    value = \"XS\"    page = \"\"\"  # Slider - List of values    <|{value}|slider|lov=XXS;XS;S;M;L;XL;XXL|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import io  from decimal import Decimal, getcontext    from taipy.gui import Gui, download    # Initial precision  precision = 10      def pi(precision: int) -> list[int]:      \"\"\"Compute Pi to the required precision.        Adapted from https://docs.python.org/3/library/decimal.html      \"\"\"      saved_precision = getcontext().prec  # Save precision      getcontext().prec = precision      three = Decimal(3)  # substitute \"three=3.0\" for regular floats      lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 24      while s != lasts:          lasts = s          n, na = n + na, na + 8          d, da = d + da, da + 32          t = (t * n) / d          s += t      digits = []      while s != 0:          integral = int(s)          digits.append(integral)          s = (s - integral) * 10      getcontext().prec = saved_precision      return digits      # Generate the digits, save them in a CSV file content, and trigger a download action  # so the user can retrieve them  def download_pi(state):      digits = pi(state.precision)      buffer = io.StringIO()      buffer.write(\"index,digit\\n\")      for i, d in enumerate(digits):          buffer.write(f\"{i},{d}\\n\")      download(state, content=bytes(buffer.getvalue(), \"UTF-8\"), name=\"pi.csv\")      page = \"\"\"  # File Download - Dynamic content    Precision:    <|{precision}|slider|min=2|max=10000|>    <|{None}|file_download|on_action=download_pi|label=Download Pi digits|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    value = 9    page = \"\"\"  # Slider - Custom range    <|{value}|slider|min=1|max=10|>    Value: <|{value}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from datetime import date, timedelta    from taipy.gui import Gui    # Create the list of dates (all year 2000)  all_dates = {}  all_dates_str = []  start_date = date(2000, 1, 1)  end_date = date(2001, 1, 1)  a_date = start_date  while a_date < end_date:      date_str = a_date.strftime(\"%Y/%m/%d\")      all_dates_str.append(date_str)      all_dates[date_str] = a_date      a_date += timedelta(days=1)    # Initial selection: first and last day  dates = [all_dates_str[1], all_dates_str[-1]]  # These two variables are used in text controls  start_sel = all_dates[dates[0]]  end_sel = all_dates[dates[1]]      def on_change(state, _, var_value):      # Update the text controls      state.start_sel = all_dates[var_value[0]]      state.end_sel = all_dates[var_value[1]]      page = \"\"\"  # Slider - Date range    <|{dates}|slider|lov={all_dates_str}|>    Start: <|{start_sel}|text|format=d MMM|>    End: <|{end_sel}|text|format=d MMM|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  import os  from decimal import Decimal, getcontext  from tempfile import NamedTemporaryFile    from taipy.gui import Gui, download    # Initial precision  precision = 10  # Stores the path to the temporary file  temp_path = None      def pi(precision: int) -> list[int]:      \"\"\"Compute Pi to the required precision.        Adapted from https://docs.python.org/3/library/decimal.html      \"\"\"      saved_precision = getcontext().prec  # Save precision      getcontext().prec = precision      three = Decimal(3)  # substitute \"three=3.0\" for regular floats      lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 24      while s != lasts:          lasts = s          n, na = n + na, na + 8          d, da = d + da, da + 32          t = (t * n) / d          s += t      digits = []      while s != 0:          integral = int(s)          digits.append(integral)          s = (s - integral) * 10      getcontext().prec = saved_precision      return digits      # Remove the temporary file  def clean_up(state):      os.remove(state.temp_path)      # Generate the digits, save them in a CSV temporary file, then trigger a download action  # for that file.  def download_pi(state):      digits = pi(state.precision)      with NamedTemporaryFile(\"r+t\", suffix=\".csv\", delete=False) as temp_file:          state.temp_path = temp_file.name          temp_file.write(\"index,digit\\n\")          for i, d in enumerate(digits):              temp_file.write(f\"{i},{d}\\n\")      download(state, content=temp_file.name, name=\"pi.csv\", on_action=clean_up)      page = \"\"\"  # File Download - Dynamic content    Precision:    <|{precision}|slider|min=2|max=10000|>    <|{None}|file_download|on_action=download_pi|label=Download Pi digits|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    value = 50    page = \"\"\"  # Slider - Simple    <|{value}|slider|>    Value: <|{value}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    value = 40    page = \"\"\"  # Slider - Vertical    <|{value}|slider|orientation=v|>    Value: <|{value}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  # -----------------------------------------------------------------------------------------  # To execute this script, make sure that the taipy-gui package is installed in your  # Python environment and run:  #     python <script>  # -----------------------------------------------------------------------------------------  from taipy.gui import Gui    # Initial values  values = [20, 40, 80]    page = \"\"\"  # Slider - Range    <|{values}|slider|>    Selection: <|{values}|>  \"\"\"    Gui(page).run() "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from importlib.util import find_spec    if find_spec(\"taipy\"):      if find_spec(\"taipy.config\"):          from taipy.config._init import *  # type: ignore        if find_spec(\"taipy.gui\"):          from taipy.gui._init import *  # type: ignore        if find_spec(\"taipy.core\"):          from taipy.core._init import *  # type: ignore        if find_spec(\"taipy.rest\"):          from taipy.rest._init import *  # type: ignore        if find_spec(\"taipy.gui_core\"):          from taipy.gui_core._init import *  # type: ignore        if find_spec(\"taipy.enterprise\"):          from taipy.enterprise._init import *  # type: ignore        if find_spec(\"taipy._run\"):          from taipy._run import _run as run  # type: ignore "}
{"text": "import typing as t      class Icon:      \"\"\"Small image in the User Interface.        Icons are typically used in controls like [button](../gui/viselements/button.md)      or items in a [menu](../gui/viselements/menu.md).        Attributes:          path (str): The path to the image file.          text (Optional[str]): The text associated to the image or None if there is none.          svg (Optional[bool]): True if the image is svg.        If a text is associated to an icon, it is rendered by the visual elements that      uses this Icon.      \"\"\"        @staticmethod      def get_dict_or(value: t.Union[str, t.Any]) -> t.Union[str, dict]:          return value._to_dict() if isinstance(value, Icon) else value        def __init__(          self,          path: str,          text: t.Optional[str] = None,          light_path: t.Optional[bool] = None,          dark_path: t.Optional[bool] = None,      ) -> None:          \"\"\"Initialize a new Icon.            Arguments:              path (str): The path to an image file.<br/>                  This path must be relative to and inside the root directory of the                  application (where the Python file that created the `Gui` instance                  is located).<br/>                  In situations where the image file is located outside the application                  directory, a _path mapping_ must be used: the _path_mapping_ parameter                  of the `Gui^` constructor makes it possible to access a resource anywhere                  on the server filesystem, as if it were located in a subdirectory of                  the application directory.              text (Optional[str]): The text associated to the image. If *text* is None,                  there is no text associated to this image.              light_path (Optional[str]): The path to the light theme image (fallback to *path* if not defined).              dark_path (Optional[str]): The path to the dark theme image (fallback to *path* if not defined).          \"\"\"          self.path = path          self.text = text          if light_path is not None:              self.light_path = light_path          if dark_path is not None:              self.dark_path = dark_path        def _to_dict(self, a_dict: t.Optional[dict] = None) -> dict:          if a_dict is None:              a_dict = {}          a_dict[\"path\"] = self.path          if self.text is not None:              a_dict[\"text\"] = self.text          if hasattr(self, \"light_path\") and self.light_path is not None:              a_dict[\"lightPath\"] = self.light_path          if hasattr(self, \"dark_path\") and self.dark_path is not None:              a_dict[\"darkPath\"] = self.dark_path          return a_dict "}
{"text": "from .gui import Gui "}
{"text": "\"\"\"# Taipy Graphical User Interface generator    The Taipy GUI package provides User Interface generation based on page templates. It can  run a web server that a web browser can connect to.    The pages are generated by a web server that allows web clients to connect, display and  interact with the page content through visual elements.    Each page can contain regular text and images, as well as Taipy controls that are  typically linked to some value that is managed by the whole Taipy application.    Here is how you can create your first Taipy User Interface:       - Create a Python source file.       Copy these two lines into a file called *taipy_app.py*.       ```py title=\"taipy_app.py\"       from taipy import Gui       Gui(\"# Hello Taipy!\").run()       ```     - Install Taipy:       ```       pip install taipy       ```     - Run your application:       ```       python taipy_app.py       ```    Your browser opens a new page, showing the content of your graphical  application.    !!! Note \"Optional packages\"        There are Python packages that you can install in your environment to      add functionality to Taipy GUI:        - [`python-magic`](https://pypi.org/project/python-magic/): identifies image format        from byte buffers so the [`image`](../../gui/viselements/image.md) control can        display them, and so that [`file_download`](../../gui/viselements/file_download.md)        can request the browser to display the image content when relevant.<br/>        You can install that package with the regular `pip install python-magic` command        (then potentially `pip install python-magic` on Windows),        or install Taipy GUI using: `pip install taipy-gui[image]`.      - [`pyarrow`](https://pypi.org/project/pyarrow/): can improve the performance of your        application by reducing the volume of data transferred between the web server and the        clients. This is relevant if your application uses large tabular data.<br/>        You can install that package with the regular `pip install pyarrow` command,        or install Taipy GUI using: `pip install taipy-gui[arrow]`.      - [`simple-websocket`](https://pypi.org/project/simple-websocket/): enables the        debugging of the WebSocket part of the server execution.<br/>        You can install that package with the regular `pip install simple-websocket` command,        or install Taipy GUI using: `pip install taipy-gui[simple-websocket]`.      - [`pyngrok`](https://pypi.org/project/pyngrok/): enables use of [Ngrok](https://ngrok.com/)        to access Taipy GUI application from the internet.<br/>        You can install that package with the regular `pip install pyngrok` command,        or install Taipy GUI using: `pip install taipy-gui[pyngrok]`.    \"\"\"    from importlib.util import find_spec    from ._init import *  from ._renderers import Html, Markdown  from .gui_actions import (      broadcast_callback,      download,      get_module_context,      get_module_name_from_state,      get_state_id,      get_user_content_url,      hold_control,      invoke_callback,      invoke_long_callback,      navigate,      notify,      resume_control,  )  from .icon import Icon  from .page import Page  from .partial import Partial  from .state import State  from .utils import is_debugging    if find_spec(\"taipy\") and find_spec(\"taipy.config\"):      from taipy.config import _inject_section        from ._default_config import default_config      from ._gui_section import _GuiSection        _inject_section(          _GuiSection,          \"gui_config\",          _GuiSection(property_list=list(default_config)),          [(\"configure_gui\", _GuiSection._configure)],          add_to_unconflicted_sections=True,      ) "}
{"text": "from __future__ import annotations    import inspect  import typing as t  from types import FrameType    from .utils import _filter_locals, _get_module_name_from_frame    if t.TYPE_CHECKING:      from ._renderers import _Element      class Page:      \"\"\"Generic page generator.        The `Page` class transforms template text into actual pages that can be displayed      on a web browser.        When a page is requested to be displayed, it is converted into HTML      code that can be sent to the client. All control placeholders are      replaced by their respective graphical component so you can show      your application variables and interact with them.      \"\"\"        def __init__(self, **kwargs) -> None:          self._class_module_name = \"\"          self._class_locals: t.Dict[str, t.Any] = {}          self._frame: t.Optional[FrameType] = None          self._renderer: t.Optional[Page] = self.create_page()          if \"frame\" in kwargs:              self._frame = kwargs.get(\"frame\")          elif self._renderer:              self._frame = self._renderer._frame          elif len(inspect.stack()) < 4:              raise RuntimeError(f\"Can't resolve module. Page '{type(self).__name__}' is not registered.\")          else:              self._frame = t.cast(FrameType, t.cast(FrameType, inspect.stack()[3].frame))          if self._renderer:              # Extract the page module's attributes and methods              cls = type(self)              cls_locals = dict(vars(self))              funcs = [                  i[0]                  for i in inspect.getmembers(cls)                  if not i[0].startswith(\"_\") and (inspect.ismethod(i[1]) or inspect.isfunction(i[1]))              ]              for f in funcs:                  func = getattr(self, f)                  if hasattr(func, \"__func__\") and func.__func__ is not None:                      cls_locals[f] = func.__func__              self._class_module_name = cls.__name__              self._class_locals = cls_locals        def create_page(self) -> t.Optional[Page]:          \"\"\"Create the page content for page modules.            If this page is a page module, this method must be overloaded and return the page content.            This method should never be called directly: only the Taipy GUI internals will.            The default implementation returns None, indicating that this class does not implement          a page module.            Returns:              The page content for this Page subclass, making it a page module.          \"\"\"          return None        def _get_locals(self) -> t.Optional[t.Dict[str, t.Any]]:          return (              self._class_locals              if self._is_class_module()              else None              if (frame := self._get_frame()) is None              else _filter_locals(frame.f_locals)          )        def _is_class_module(self):          return self._class_module_name != \"\"        def _get_frame(self):          if not hasattr(self, \"_frame\"):              raise RuntimeError(f\"Page '{type(self).__name__}' was not registered correctly.\")          return self._frame        def _get_module_name(self) -> t.Optional[str]:          return (              None              if (frame := self._get_frame()) is None              else f\"{_get_module_name_from_frame(frame)}{'.' if self._class_module_name else ''}{self._class_module_name}\"          )        def _get_content_detail(self, gui) -> str:          return f\"in class {type(self).__name__}\"        def render(self, gui) -> str:          if self._renderer is not None:              return self._renderer.render(gui)          return \"<h1>No renderer found for page</h1>\" "}
{"text": "import sys  import traceback  import typing as t  import warnings      class TaipyGuiWarning(UserWarning):      \"\"\"NOT DOCUMENTED        Warning category for Taipy warnings generated in user code.      \"\"\"        _tp_debug_mode = False        @staticmethod      def set_debug_mode(debug_mode: bool):          TaipyGuiWarning._tp_debug_mode = (              debug_mode if debug_mode else hasattr(sys, \"gettrace\") and sys.gettrace() is not None          )      def _warn(message: str, e: t.Optional[BaseException] = None):      warnings.warn(          f\"{message}:\\n{''.join(traceback.format_exception(type(e), e, e.__traceback__))}\"          if e and TaipyGuiWarning._tp_debug_mode          else f\"{message}:\\n{e}\"          if e          else message,          TaipyGuiWarning,          stacklevel=2,      ) "}
{"text": "import typing as t  from copy import copy    from taipy.config import Config as TaipyConfig  from taipy.config import UniqueSection    from ._default_config import default_config      class _GuiSection(UniqueSection):      name = \"gui\"        def __init__(self, property_list: t.Optional[t.List] = None, **properties):          self._property_list = property_list          super().__init__(**properties)        def __copy__(self):          return _GuiSection(property_list=copy(self._property_list), **copy(self._properties))        def _clean(self):          self._properties.clear()        def _to_dict(self):          as_dict = {}          as_dict.update(self._properties)          return as_dict        @classmethod      def _from_dict(cls, as_dict: t.Dict[str, t.Any], *_):          return _GuiSection(property_list=list(default_config), **as_dict)        def _update(self, as_dict: t.Dict[str, t.Any]):          if self._property_list:              as_dict = {k: v for k, v in as_dict.items() if k in self._property_list}          self._properties.update(as_dict)        @staticmethod      def _configure(**properties) -> \"_GuiSection\":          \"\"\"NOT DOCUMENTED          Configure the Graphical User Interface.            Parameters:              **properties (dict[str, any]): Keyword arguments that configure the behavior of the `Gui^` instances.<br/>                  Please refer to the                  [Configuration section](../gui/configuration.md#configuring-the-gui-instance)                  of the User Manual for more information on the accepted arguments.          Returns:              The GUI configuration.            \"\"\"          section = _GuiSection(property_list=list(default_config), **properties)          TaipyConfig._register(section)          return TaipyConfig.unique_sections[_GuiSection.name] "}
{"text": "import typing as t  from enum import Enum  from inspect import isclass    from .data import Decimator  from .utils import (      _TaipyBase,      _TaipyBool,      _TaipyContent,      _TaipyContentHtml,      _TaipyContentImage,      _TaipyData,      _TaipyDate,      _TaipyDateRange,      _TaipyDict,      _TaipyLoNumbers,      _TaipyLov,      _TaipyLovValue,      _TaipyNumber,  )      class _WsType(Enum):      ACTION = \"A\"      MULTIPLE_UPDATE = \"MU\"      REQUEST_UPDATE = \"RU\"      DATA_UPDATE = \"DU\"      UPDATE = \"U\"      ALERT = \"AL\"      BLOCK = \"BL\"      NAVIGATE = \"NA\"      CLIENT_ID = \"ID\"      MULTIPLE_MESSAGE = \"MS\"      DOWNLOAD_FILE = \"DF\"      PARTIAL = \"PR\"      ACKNOWLEDGEMENT = \"ACK\"      NumberTypes = {\"int\", \"int64\", \"float\", \"float64\"}      class PropertyType(Enum):      \"\"\"      All the possible element property types.        This is used when creating custom visual elements, where you have      to indicate the type of each property.        Some types are 'dynamic', meaning that if the property value is modified, it      is automatically handled by Taipy and propagated to the entire application.        See `ElementProperty^` for more details.      \"\"\"        boolean = \"boolean\"      \"\"\"      The property holds a Boolean value.      \"\"\"      toHtmlContent = _TaipyContentHtml      content = _TaipyContent      data = _TaipyData      date = _TaipyDate      date_range = _TaipyDateRange      dict = \"dict\"      \"\"\"      The property holds a dictionary.      \"\"\"      dynamic_dict = _TaipyDict      \"\"\"      The property holds a dynamic dictionary.      \"\"\"      dynamic_number = _TaipyNumber      \"\"\"      The property holds a dynamic number.      \"\"\"      dynamic_lo_numbers = _TaipyLoNumbers      \"\"\"      The property holds a dynamic list of numbers.      \"\"\"      dynamic_boolean = _TaipyBool      \"\"\"      The property holds a dynamic Boolean value.      \"\"\"      dynamic_list = \"dynamiclist\"      dynamic_string = \"dynamicstring\"      \"\"\"      The property holds a dynamic string.      \"\"\"      function = \"function\"      \"\"\"      The property holds a reference to a function.      \"\"\"      image = _TaipyContentImage      json = \"json\"      lov = _TaipyLov      \"\"\"      The property holds a LoV (list of values).      \"\"\"      lov_value = _TaipyLovValue      \"\"\"      The property holds a value in a LoV (list of values).      \"\"\"      number = \"number\"      \"\"\"      The property holds a number.      \"\"\"      react = \"react\"      broadcast = \"broadcast\"      string = \"string\"      \"\"\"      The property holds a string.      \"\"\"      string_or_number = \"string|number\"      \"\"\"      The property holds a string or a number.        This is typically used to handle CSS dimension values, where a unit can be used.      \"\"\"      boolean_or_list = \"boolean|list\"      slider_value = \"number|number[]|lovValue\"      string_list = \"stringlist\"      decimator = Decimator      \"\"\"      The property holds an inner attributes that is defined by a library and cannot be overridden by the user.      \"\"\"      inner = \"inner\"      @t.overload  def _get_taipy_type(a_type: None) -> None:      ...      @t.overload  def _get_taipy_type(a_type: t.Type[_TaipyBase]) -> t.Type[_TaipyBase]:      ...      @t.overload  def _get_taipy_type(a_type: PropertyType) -> t.Type[_TaipyBase]:      ...      @t.overload  def _get_taipy_type(      a_type: t.Optional[t.Union[t.Type[_TaipyBase], t.Type[Decimator], PropertyType]]  ) -> t.Optional[t.Union[t.Type[_TaipyBase], t.Type[Decimator], PropertyType]]:      ...      def _get_taipy_type(      a_type: t.Optional[t.Union[t.Type[_TaipyBase], t.Type[Decimator], PropertyType]]  ) -> t.Optional[t.Union[t.Type[_TaipyBase], t.Type[Decimator], PropertyType]]:      if a_type is None:          return None      if isinstance(a_type, PropertyType) and not isinstance(a_type.value, str):          return a_type.value      if isclass(a_type) and not isinstance(a_type, PropertyType) and issubclass(a_type, _TaipyBase):          return a_type      if a_type == PropertyType.boolean:          return _TaipyBool      elif a_type == PropertyType.number:          return _TaipyNumber      return None "}
{"text": "# _Page for multipage support  from __future__ import annotations    import logging  import typing as t  import warnings    if t.TYPE_CHECKING:      from ._renderers import Page      from .gui import Gui      class _Page(object):      def __init__(self):          self._rendered_jsx: t.Optional[str] = None          self._renderer: t.Optional[Page] = None          self._style: t.Optional[str] = None          self._route: t.Optional[str] = None          self._head: t.Optional[list] = None        def render(self, gui: Gui):          if self._renderer is None:              raise RuntimeError(f\"Can't render page {self._route}: no renderer found\")          with warnings.catch_warnings(record=True) as w:              warnings.resetwarnings()              with gui._set_locals_context(self._renderer._get_module_name()):                  self._rendered_jsx = self._renderer.render(gui)              if w:                  s = \"\\033[1;31m\\n\"                  s += (                      message := f\"--- {len(w)} warning(s) were found for page '{'/' if self._route == gui._get_root_page_name() else self._route}' {self._renderer._get_content_detail(gui)} ---\\n\"                  )                  for i, wm in enumerate(w):                      s += f\" - Warning {i + 1}: {wm.message}\\n\"                  s += \"-\" * len(message)                  s += \"\\033[0m\\n\"                  logging.warn(s)          if hasattr(self._renderer, \"head\"):              self._head = list(self._renderer.head)  # type: ignore          # return renderer module_name from frame          return self._renderer._get_module_name() "}
{"text": "from .config import Config, Stylekit    _default_stylekit: Stylekit = {      # Primary and secondary colors      \"color_primary\": \"#ff6049\",      \"color_secondary\": \"#293ee7\",      # Contextual color      \"color_error\": \"#FF595E\",      \"color_warning\": \"#FAA916\",      \"color_success\": \"#96E6B3\",      # Background and elevation color for LIGHT MODE      \"color_background_light\": \"#f0f5f7\",      \"color_paper_light\": \"#ffffff\",      # Background and elevation color for DARK MODE      \"color_background_dark\": \"#152335\",      \"color_paper_dark\": \"#1f2f44\",      # DEFINING FONTS      # Set main font family      \"font_family\": \"Lato, Arial, sans-serif\",      # DEFINING ROOT STYLES      # Set root margin      \"root_margin\": \"1rem\",      # DEFINING SHAPES      # Base border radius in px      \"border_radius\": 8,      # DEFINING MUI COMPONENTS STYLES      # Matching input and button height in css size unit      \"input_button_height\": \"48px\",  }    # Default config loaded by app.py  default_config: Config = {      \"allow_unsafe_werkzeug\": False,      \"async_mode\": \"gevent\",      \"change_delay\": None,      \"chart_dark_template\": None,      \"base_url\": \"/\",      \"dark_mode\": True,      \"dark_theme\": None,      \"debug\": False,      \"extended_status\": False,      \"favicon\": None,      \"flask_log\": False,      \"host\": \"127.0.0.1\",      \"light_theme\": None,      \"margin\": \"1em\",      \"ngrok_token\": \"\",      \"notebook_proxy\": True,      \"notification_duration\": 3000,      \"propagate\": True,      \"run_browser\": True,      \"run_in_thread\": False,      \"run_server\": True,      \"server_config\": None,      \"single_client\": False,      \"system_notification\": False,      \"theme\": None,      \"time_zone\": None,      \"title\": None,      \"stylekit\": _default_stylekit.copy(),      \"upload_folder\": None,      \"use_arrow\": False,      \"use_reloader\": False,      \"watermark\": \"Taipy inside\",      \"webapp_path\": None,      \"port\": 5000,  } "}
{"text": "from __future__ import annotations    import typing as t    from ._page import _Page  from ._warnings import _warn  from .state import State    if t.TYPE_CHECKING:      from .page import Page      class Partial(_Page):      \"\"\"Re-usable Page content.        Partials are used when you need to use a partial page content in different      and not related pages. This allows not to have to repeat yourself when      creating your page templates.        Visual elements such as [`part`](../gui/viselements/part.md),      [`dialog`](../gui/viselements/dialog.md) or      [`pane`](../gui/viselements/pane.md) can use Partials.        Note that `Partial` has no constructor (no `__init__()` method): to create a      `Partial`, you must call the `Gui.add_partial()^` function.        Partials can be really handy if you want to modify a section of a page:      the `update_content()` method dynamically update pages that make use      of this `Partial` therefore making it easy to change the content of      any page, at any moment.      \"\"\"        _PARTIALS = \"__partials\"        __partials: t.Dict[str, Partial] = {}        def __init__(self, route: t.Optional[str] = None):          super().__init__()          if route is None:              self._route = f\"TaiPy_partials_{len(Partial.__partials)}\"              Partial.__partials[self._route] = self          else:              self._route = route        def update_content(self, state: State, content: str | \"Page\"):          \"\"\"Update partial content.            Arguments:              state (State^): The current user state as received in any callback.              content (str): The new content to use and display.          \"\"\"          if state and state._gui and callable(state._gui._update_partial):              state._gui._update_partial(self.__copy(content))          else:              _warn(\"'Partial.update_content()' must be called in the context of a callback.\")        def __copy(self, content: str | \"Page\") -> Partial:          new_partial = Partial(self._route)          from .page import Page            if isinstance(content, Page):              new_partial._renderer = content          else:              new_partial._renderer = type(self._renderer)(content=content) if self._renderer is not None else None          return new_partial "}
{"text": "from typing import Dict, Tuple    from taipy._cli._base_cli import _CLI      class _GuiCLI:      \"\"\"Command-line interface of GUI.\"\"\"        __GUI_ARGS: Dict[Tuple, Dict] = {          (\"--port\", \"-P\"): {              \"dest\": \"taipy_port\",              \"metavar\": \"PORT\",              \"nargs\": \"?\",              \"default\": \"\",              \"const\": \"\",              \"help\": \"Specify server port\",          },          (\"--host\", \"-H\"): {              \"dest\": \"taipy_host\",              \"metavar\": \"HOST\",              \"nargs\": \"?\",              \"default\": \"\",              \"const\": \"\",              \"help\": \"Specify server host\",          },          (\"--ngrok-token\",): {              \"dest\": \"taipy_ngrok_token\",              \"metavar\": \"NGROK_TOKEN\",              \"nargs\": \"?\",              \"default\": \"\",              \"const\": \"\",              \"help\": \"Specify NGROK Authtoken\",          },          (\"--webapp-path\",): {              \"dest\": \"taipy_webapp_path\",              \"metavar\": \"WEBAPP_PATH\",              \"nargs\": \"?\",              \"default\": \"\",              \"const\": \"\",              \"help\": \"The path to the web app to be used. The default is the webapp directory under gui in the Taipy GUI package directory.\",          },      }        __DEBUG_ARGS: Dict[str, Dict] = {          \"--debug\": {\"dest\": \"taipy_debug\", \"help\": \"Turn on debug\", \"action\": \"store_true\"},          \"--no-debug\": {\"dest\": \"taipy_no_debug\", \"help\": \"Turn off debug\", \"action\": \"store_true\"},      }        __RELOADER_ARGS: Dict[str, Dict] = {          \"--use-reloader\": {\"dest\": \"taipy_use_reloader\", \"help\": \"Auto reload on code changes\", \"action\": \"store_true\"},          \"--no-reloader\": {\"dest\": \"taipy_no_reloader\", \"help\": \"No reload on code changes\", \"action\": \"store_true\"},      }        @classmethod      def create_parser(cls):          gui_parser = _CLI._add_groupparser(\"Taipy GUI\", \"Optional arguments for Taipy GUI service\")            for args, arg_dict in cls.__GUI_ARGS.items():              taipy_arg = (args[0], cls.__add_taipy_prefix(args[0]), *args[1:])              gui_parser.add_argument(*taipy_arg, **arg_dict)            debug_group = gui_parser.add_mutually_exclusive_group()          for debug_arg, debug_arg_dict in cls.__DEBUG_ARGS.items():              debug_group.add_argument(debug_arg, cls.__add_taipy_prefix(debug_arg), **debug_arg_dict)            reloader_group = gui_parser.add_mutually_exclusive_group()          for reloader_arg, reloader_arg_dict in cls.__RELOADER_ARGS.items():              reloader_group.add_argument(reloader_arg, cls.__add_taipy_prefix(reloader_arg), **reloader_arg_dict)        @classmethod      def create_run_parser(cls):          run_parser = _CLI._add_subparser(\"run\", help=\"Run a Taipy application.\")          for args, arg_dict in cls.__GUI_ARGS.items():              run_parser.add_argument(*args, **arg_dict)            debug_group = run_parser.add_mutually_exclusive_group()          for debug_arg, debug_arg_dict in cls.__DEBUG_ARGS.items():              debug_group.add_argument(debug_arg, **debug_arg_dict)            reloader_group = run_parser.add_mutually_exclusive_group()          for reloader_arg, reloader_arg_dict in cls.__RELOADER_ARGS.items():              reloader_group.add_argument(reloader_arg, **reloader_arg_dict)        @classmethod      def parse_arguments(cls):          return _CLI._parse()        @classmethod      def __add_taipy_prefix(cls, key: str):          if key.startswith(\"--no-\"):              return key[:5] + \"taipy-\" + key[5:]            return key[:2] + \"taipy-\" + key[2:] "}
{"text": "from ..types import PropertyType  from .library import Element, ElementLibrary, ElementProperty "}
{"text": "from __future__ import annotations    import typing as t      class _MapDict(object):      \"\"\"      Provide class binding, can utilize getattr, setattr functionality      Also perform update operation      \"\"\"        __local_vars = (\"_dict\", \"_update_var\")        def __init__(self, dict_import: dict, app_update_var=None):          self._dict = dict_import          # Bind app update var function          self._update_var = app_update_var        def __len__(self):          return self._dict.__len__()        def __length_hint__(self):          return self._dict.__length_hint__()        def __getitem__(self, key):          value = self._dict.__getitem__(key)          if isinstance(value, dict):              if self._update_var:                  return _MapDict(value, lambda s, v: self._update_var(f\"{key}.{s}\", v))              else:                  return _MapDict(value)          return value        def __setitem__(self, key, value):          if self._update_var:              self._update_var(key, value)          else:              self._dict.__setitem__(key, value)        def __delitem__(self, key):          self._dict.__delitem__(key)        def __missing__(self, key):          return self._dict.__missing__(key)        def __iter__(self):          return self._dict.__iter__()        def __reversed__(self):          return self._dict.__reversed__()        def __contains__(self, item):          return self._dict.__contains__(item)        # to be able to use getattr      def __getattr__(self, attr):          value = self._dict.__getitem__(attr)          if isinstance(value, dict):              if self._update_var:                  return _MapDict(value, lambda s, v: self._update_var(f\"{attr}.{s}\", v))              else:                  return _MapDict(value)          return value        def __setattr__(self, attr, value):          if attr in _MapDict.__local_vars:              super().__setattr__(attr, value)          else:              self.__setitem__(attr, value)        def keys(self):          return self._dict.keys()        def values(self):          return self._dict.values()        def items(self):          return self._dict.items()        def get(self, key: t.Any, default_value: t.Optional[str] = None) -> t.Optional[t.Any]:          return self._dict.get(key, default_value)        def clear(self) -> None:          self._dict.clear()        def setdefault(self, key, value=None) -> t.Optional[t.Any]:          return self._dict.setdefault(key, value)        def pop(self, key, default=None) -> t.Any:          return self._dict.pop(key, default)        def popitem(self) -> tuple:          return self._dict.popitem()        def copy(self) -> _MapDict:          return _MapDict(self._dict.copy(), self._update_var)        def update(self, d: dict) -> None:          current_keys = self.keys()          for k, v in d.items():              if k not in current_keys or self[k] != v:                  self.__setitem__(k, v) "}
{"text": "import re  import typing as t    _RE_MODULE = re.compile(r\"^__(.*?)__$\")      def _filter_locals(locals_dict: t.Dict[str, t.Any]) -> t.Dict[str, t.Any]:      return {k: v for k, v in locals_dict.items() if (not _RE_MODULE.match(k) or k == \"__name__\")} "}
{"text": "import typing as t    from .singleton import _Singleton    if t.TYPE_CHECKING:      from ..gui import Gui      class _RuntimeManager(object, metaclass=_Singleton):      def __init__(self):          self.__port_gui: t.Dict[int, \"Gui\"] = {}        def add_gui(self, gui: \"Gui\", port: int):          if port in self.__port_gui:              self.__port_gui[port].stop()          self.__port_gui[port] = gui        def get_used_port(self):          return list(self.__port_gui.keys()) "}
{"text": "import inspect  import sys  import typing as t  from types import FrameType, ModuleType      def _get_module_name_from_frame(frame: FrameType):      return frame.f_globals[\"__name__\"] if \"__name__\" in frame.f_globals else None      def _get_module_name_from_imported_var(var_name: str, value: t.Any, sub_module_name: str) -> str:      module_list = sys.modules.copy()      # the provided sub_module_name are expected to contain only part of the full module_name provided by sys.modules      # --> we can find potential matched modules based on the sub_module_name      potential_matched_module = [m for m in module_list.keys() if m.endswith(sub_module_name)]      for m in potential_matched_module:          module = module_list[m]          if hasattr(module, var_name) and getattr(module, var_name) is value:              return m      # failed fetching any matched module with variable and value      return sub_module_name "}
{"text": "# flake8: noqa: E402  import contextlib  import typing as t  import warnings  from threading import Thread  from urllib.parse import quote as urlquote  from urllib.parse import urlparse    warnings.filterwarnings(      \"ignore\",      category=UserWarning,      message=\"You do not have a working installation of the service_identity module: 'No module named 'service_identity''.*\",  )  from twisted.internet import reactor  from twisted.web.proxy import ProxyClient, ProxyClientFactory  from twisted.web.resource import Resource  from twisted.web.server import NOT_DONE_YET, Site    from .is_port_open import _is_port_open  from .singleton import _Singleton    if t.TYPE_CHECKING:      from ..gui import Gui      def _modifiedHandleResponseEnd(self):      if self._finished:          return      self._finished = True      with contextlib.suppress(Exception):          self.father.finish()      self.transport.loseConnection()      setattr(ProxyClient, \"handleResponseEnd\", _modifiedHandleResponseEnd)      class _TaipyReverseProxyResource(Resource):      proxyClientFactoryClass = ProxyClientFactory        def __init__(self, host, path, gui: \"Gui\", reactor=reactor):          Resource.__init__(self)          self.host = host          self.path = path          self.reactor = reactor          self._gui = gui        def getChild(self, path, request):          return _TaipyReverseProxyResource(              self.host,              self.path + b\"/\" + urlquote(path, safe=b\"\").encode(\"utf-8\"),              self._gui,              self.reactor,          )        def _get_port(self):          return self._gui._server._port        def render(self, request):          port = self._get_port()          host = self.host if port == 80 else \"%s:%d\" % (self.host, port)          request.requestHeaders.setRawHeaders(b\"host\", [host.encode(\"ascii\")])          request.content.seek(0, 0)          rest = self.path + b\"?\" + qs if (qs := urlparse(request.uri)[4]) else self.path          clientFactory = self.proxyClientFactoryClass(              request.method,              rest,              request.clientproto,              request.getAllHeaders(),              request.content.read(),              request,          )          self.reactor.connectTCP(self.host, port, clientFactory)          return NOT_DONE_YET      class NotebookProxy(object, metaclass=_Singleton):      def __init__(self, gui: \"Gui\", listening_port: int) -> None:          self._listening_port = listening_port          self._gui = gui          self._is_running = False        def run(self):          if self._is_running:              return          host = self._gui._get_config(\"host\", \"127.0.0.1\")          port = self._listening_port          if _is_port_open(host, port):              raise ConnectionError(                  f\"Port {port} is already opened on {host}. You have another server application running on the same port.\"              )          site = Site(_TaipyReverseProxyResource(host, b\"\", self._gui))          reactor.listenTCP(port, site)          Thread(target=reactor.run, args=(False,)).start()          self._is_running = True        def stop(self):          if not self._is_running:              return          self._is_running = False          reactor.stop() "}
{"text": "import typing as t  from operator import attrgetter    if t.TYPE_CHECKING:      from ..gui import Gui      def _getscopeattr(gui: \"Gui\", name: str, *more) -> t.Any:      if more:          return getattr(gui._get_data_scope(), name, more[0])      return getattr(gui._get_data_scope(), name)      def _getscopeattr_drill(gui: \"Gui\", name: str) -> t.Any:      return attrgetter(name)(gui._get_data_scope())      def _setscopeattr(gui: \"Gui\", name: str, value: t.Any):      if gui._is_broadcasting():          for scope in gui._get_all_data_scopes().values():              setattr(scope, name, value)      else:          setattr(gui._get_data_scope(), name, value)      def _setscopeattr_drill(gui: \"Gui\", name: str, value: t.Any):      if gui._is_broadcasting():          for scope in gui._get_all_data_scopes().values():              _attrsetter(scope, name, value)      else:          _attrsetter(gui._get_data_scope(), name, value)      def _hasscopeattr(gui: \"Gui\", name: str) -> bool:      return hasattr(gui._get_data_scope(), name)      def _delscopeattr(gui: \"Gui\", name: str):      delattr(gui._get_data_scope(), name)      def _attrsetter(obj: object, attr_str: str, value: object) -> None:      var_name_split = attr_str.split(sep=\".\")      for i in range(len(var_name_split) - 1):          sub_name = var_name_split[i]          obj = getattr(obj, sub_name)      setattr(obj, var_name_split[-1], value) "}
{"text": "import typing as t      def _get_css_var_value(value: t.Any) -> str:      if isinstance(value, str):          if \" \" in value:              return f'\"{value}\"'          return value      if isinstance(value, int):          return f\"{value}px\"      return f\"{value}\" "}
{"text": "import typing as t  from types import ModuleType    from ..page import Page      def _get_page_from_module(module: ModuleType) -> t.Optional[Page]:      return next((v for v in vars(module).values() if isinstance(v, Page)), None) "}
{"text": "from __future__ import annotations    import typing as t    if t.TYPE_CHECKING:      from ..gui import Gui      def _varname_from_content(gui: Gui, content: str) -> t.Optional[str]:      return next((k for k, v in gui._get_locals_bind().items() if isinstance(v, str) and v == content), None) "}
{"text": "from __future__ import annotations    import contextlib  import typing as t    from flask import g      class _LocalsContext:      __ctx_g_name = \"locals_context\"        def __init__(self) -> None:          self.__default_module: str = \"\"          self._lc_stack: t.List[str] = []          self._locals_map: t.Dict[str, t.Dict[str, t.Any]] = {}        def set_default(self, default: t.Dict[str, t.Any], default_module_name: str = \"\") -> None:          self.__default_module = default_module_name          self._locals_map[self.__default_module] = default        def get_default(self) -> t.Dict[str, t.Any]:          return self._locals_map[self.__default_module]        def get_all_keys(self) -> t.Set[str]:          keys = set()          for v in self._locals_map.values():              for i in v.keys():                  keys.add(i)          return keys        def get_all_context(self):          return self._locals_map.keys()        def add(self, context: t.Optional[str], locals_dict: t.Optional[t.Dict[str, t.Any]]):          if context is not None and locals_dict is not None and context not in self._locals_map:              self._locals_map[context] = locals_dict        @contextlib.contextmanager      def set_locals_context(self, context: t.Optional[str]) -> t.Iterator[None]:          try:              if context in self._locals_map:                  if hasattr(g, _LocalsContext.__ctx_g_name):                      self._lc_stack.append(getattr(g, _LocalsContext.__ctx_g_name))                  setattr(g, _LocalsContext.__ctx_g_name, context)              yield          finally:              if hasattr(g, _LocalsContext.__ctx_g_name):                  if len(self._lc_stack) > 0:                      setattr(g, _LocalsContext.__ctx_g_name, self._lc_stack.pop())                  else:                      delattr(g, _LocalsContext.__ctx_g_name)        def get_locals(self) -> t.Dict[str, t.Any]:          return self.get_default() if (context := self.get_context()) is None else self._locals_map[context]        def get_context(self) -> t.Optional[str]:          return getattr(g, _LocalsContext.__ctx_g_name) if hasattr(g, _LocalsContext.__ctx_g_name) else None        def is_default(self) -> bool:          return self.get_default() == self.get_locals()        def _get_locals_bind_from_context(self, context: t.Optional[str]):          if context is None:              context = self.__default_module          return self._locals_map[context] "}
{"text": "from ._attributes import (      _delscopeattr,      _getscopeattr,      _getscopeattr_drill,      _hasscopeattr,      _setscopeattr,      _setscopeattr_drill,  )  from ._locals_context import _LocalsContext  from ._map_dict import _MapDict  from ._runtime_manager import _RuntimeManager  from ._variable_directory import _variable_decode, _variable_encode, _VariableDirectory  from .boolean import _is_boolean, _is_boolean_true  from .clientvarname import _get_broadcast_var_name, _get_client_var_name, _to_camel_case  from .datatype import _get_data_type  from .date import _date_to_string, _string_to_date  from .expr_var_name import _get_expr_var_name  from .filename import _get_non_existent_file_path  from .filter_locals import _filter_locals  from .get_imported_var import _get_imported_var  from .get_module_name import _get_module_name_from_frame, _get_module_name_from_imported_var  from .get_page_from_module import _get_page_from_module  from .getdatecolstrname import _RE_PD_TYPE, _get_date_col_str_name  from .html import _get_css_var_value  from .is_debugging import is_debugging  from .is_port_open import _is_port_open  from .isnotebook import _is_in_notebook  from .types import (      _TaipyBase,      _TaipyBool,      _TaipyContent,      _TaipyContentHtml,      _TaipyContentImage,      _TaipyData,      _TaipyDate,      _TaipyDateRange,      _TaipyDict,      _TaipyLoNumbers,      _TaipyLov,      _TaipyLovValue,      _TaipyNumber,  )  from .varnamefromcontent import _varname_from_content "}
{"text": "import re  import typing as t    __expr_var_name_index: t.Dict[str, int] = {}  _RE_NOT_IN_VAR_NAME = r\"[^A-Za-z0-9]+\"      def _get_expr_var_name(expr: str) -> str:      var_name = re.sub(_RE_NOT_IN_VAR_NAME, \"_\", expr)      index = 0      if var_name in __expr_var_name_index.keys():          index = __expr_var_name_index[var_name]      __expr_var_name_index[var_name] = index + 1      return f\"tp_{var_name}_{index}\"      def _reset_expr_var_name():      __expr_var_name_index.clear() "}
{"text": "import socket      def _is_port_open(host, port) -> bool:      sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)      result = sock.connect_ex((host, port))      sock.close()      return result == 0 "}
{"text": "import json  import typing as t  from abc import ABC  from datetime import datetime    from .._warnings import _warn  from . import _date_to_string, _MapDict, _string_to_date, _variable_decode      class _TaipyBase(ABC):      __HOLDER_PREFIXES: t.Optional[t.List[str]] = None      _HOLDER_PREFIX = \"_Tp\"        def __init__(self, data: t.Any, hash_name: str) -> None:          self.__data = data          self.__hash_name = hash_name        def get(self):          return self.__data        def get_name(self):          return self.__hash_name        def set(self, data: t.Any):          self.__data = data        def cast_value(self, value: t.Any):          return value        def _get_readable_name(self):          try:              name, mod = _variable_decode(                  self.__hash_name[5:] if self.__hash_name.startswith(\"tpec_\") else self.__hash_name              )              return name if mod is None or mod == \"__main__\" else f\"{mod}.{name}\"          except:              return self.__hash_name        @staticmethod      def get_hash():          return NotImplementedError        @staticmethod      def _get_holder_prefixes() -> t.List[str]:          if _TaipyBase.__HOLDER_PREFIXES is None:              _TaipyBase.__HOLDER_PREFIXES = [cls.get_hash() + \"_\" for cls in _TaipyBase.__subclasses__()]          return _TaipyBase.__HOLDER_PREFIXES      class _TaipyData(_TaipyBase):      @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"D\"      class _TaipyBool(_TaipyBase):      def get(self):          return self.cast_value(super().get())        def cast_value(self, value: t.Any):          return bool(value)        @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"B\"      class _TaipyNumber(_TaipyBase):      def get(self):          try:              return float(super().get())          except Exception as e:              raise TypeError(f\"Variable '{self._get_readable_name()}' should hold a number: {e}\")        def cast_value(self, value: t.Any):          if isinstance(value, str):              try:                  return float(value) if value else 0.0              except Exception as e:                  _warn(f\"{self._get_readable_name()}: Parsing {value} as float\", e)                  return 0.0          return super().cast_value(value)        @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"N\"      class _TaipyLoNumbers(_TaipyBase):      def cast_value(self, value: t.Any):          if isinstance(value, str):              try:                  return list(map(lambda f: float(f), value[1:-1].split(\",\")))              except Exception as e:                  _warn(f\"{self._get_readable_name()}: Parsing {value} as an array of numbers\", e)                  return []          return super().cast_value(value)        @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"Ln\"      class _TaipyDate(_TaipyBase):      def get(self):          val = super().get()          if isinstance(val, datetime):              val = _date_to_string(val)          elif val is not None:              val = str(val)          return val        def cast_value(self, value: t.Any):          if isinstance(value, str):              return _string_to_date(value)          return super().cast_value(value)        @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"Dt\"      class _TaipyDateRange(_TaipyBase):      def get(self):          val = super().get()          if isinstance(val, list):              return [_date_to_string(v) if isinstance(v, datetime) else None if v is None else str(v) for v in val]          return val        def cast_value(self, value: t.Any):          if isinstance(value, list):              return [_string_to_date(v) if isinstance(v, str) else str(v) for v in value]          return super().cast_value(value)        @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"Dr\"      class _TaipyLovValue(_TaipyBase):      @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"Lv\"      class _TaipyLov(_TaipyBase):      @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"L\"      class _TaipyContent(_TaipyBase):      @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"C\"      class _TaipyContentImage(_TaipyBase):      @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"Ci\"      class _TaipyContentHtml(_TaipyBase):      @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"Ch\"      class _TaipyDict(_TaipyBase):      def get(self):          val = super().get()          return json.dumps(val._dict if isinstance(val, _MapDict) else val)        @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"Di\" "}
{"text": "import sys      def is_debugging() -> bool:      \"\"\"NOT DOCUMENTED\"\"\"      return hasattr(sys, \"gettrace\") and sys.gettrace() is not None "}
{"text": "import typing as t      def _is_boolean_true(s: t.Union[bool, str]) -> bool:      return (          s          if isinstance(s, bool)          else s.lower() in [\"true\", \"1\", \"t\", \"y\", \"yes\", \"yeah\", \"sure\"]          if isinstance(s, str)          else False      )      def _is_boolean(s: t.Any) -> bool:      if isinstance(s, bool):          return True      elif isinstance(s, str):          return s.lower() in [\"true\", \"1\", \"t\", \"y\", \"yes\", \"yeah\", \"sure\", \"false\", \"0\", \"f\", \"no\"]      else:          return False "}
{"text": "_replace_dict = {\".\": \"__\", \"[\": \"_SqrOp_\", \"]\": \"_SqrCl_\"}      def _get_client_var_name(var_name: str) -> str:      for k, v in _replace_dict.items():          var_name = var_name.replace(k, v)      return var_name      def _to_camel_case(value: str, upcase_first=False) -> str:      if not isinstance(value, str):          raise Exception(\"_to_camel_case allows only string parameter\")        if len(value) <= 1:          return value.lower()      value = value.replace(\"_\", \" \").title().replace(\" \", \"\").replace(\"[\", \"_\").replace(\"]\", \"_\")      return value[0].lower() + value[1:] if not upcase_first else value      def _get_broadcast_var_name(s: str) -> str:      return _get_client_var_name(f\"_bc_{s}\") "}
{"text": "import re  import typing as t    from .._warnings import _warn  from .boolean import _is_boolean, _is_boolean_true  from .clientvarname import _to_camel_case      def _get_column_desc(columns: t.Dict[str, t.Any], key: str) -> t.Optional[t.Dict[str, t.Any]]:      return next((x for x in columns.values() if x.get(\"dfid\") == key), None)      def _get_name_indexed_property(attributes: t.Dict[str, t.Any], name: str) -> t.Dict[str, t.Any]:      ret = {}      index_re = re.compile(name + r\"\\[(.*)\\]$\")      for key in attributes.keys():          if m := index_re.match(key):              ret[m.group(1)] = attributes.get(key)      return ret      def _update_col_desc_from_indexed(      attributes: t.Dict[str, t.Any], columns: t.Dict[str, t.Any], name: str, elt_name: str  ):      col_value = _get_name_indexed_property(attributes, name)      for k, v in col_value.items():          if col_desc := next((x for x in columns.values() if x.get(\"dfid\") == k), None):              if col_desc.get(_to_camel_case(name)) is None:                  col_desc[_to_camel_case(name)] = str(v)          else:              _warn(f\"{elt_name}: {name}[{k}] is not in the list of displayed columns.\")      def _enhance_columns(  # noqa: C901      attributes: t.Dict[str, t.Any], hash_names: t.Dict[str, str], columns: t.Dict[str, t.Any], elt_name: str  ):      _update_col_desc_from_indexed(attributes, columns, \"nan_value\", elt_name)      _update_col_desc_from_indexed(attributes, columns, \"width\", elt_name)      filters = _get_name_indexed_property(attributes, \"filter\")      for k, v in filters.items():          if _is_boolean_true(v):              if col_desc := _get_column_desc(columns, k):                  col_desc[\"filter\"] = True              else:                  _warn(f\"{elt_name}: filter[{k}] is not in the list of displayed columns.\")      editables = _get_name_indexed_property(attributes, \"editable\")      for k, v in editables.items():          if _is_boolean(v):              if col_desc := _get_column_desc(columns, k):                  col_desc[\"notEditable\"] = not _is_boolean_true(v)              else:                  _warn(f\"{elt_name}: editable[{k}] is not in the list of displayed columns.\")      group_by = _get_name_indexed_property(attributes, \"group_by\")      for k, v in group_by.items():          if _is_boolean_true(v):              if col_desc := _get_column_desc(columns, k):                  col_desc[\"groupBy\"] = True              else:                  _warn(f\"{elt_name}: group_by[{k}] is not in the list of displayed columns.\")      apply = _get_name_indexed_property(attributes, \"apply\")      for k, v in apply.items():  # pragma: no cover          if col_desc := _get_column_desc(columns, k):              if callable(v):                  value = hash_names.get(f\"apply[{k}]\")              elif isinstance(v, str):                  value = v.strip()              else:                  _warn(f\"{elt_name}: apply[{k}] should be a user or predefined function.\")                  value = None              if value:                  col_desc[\"apply\"] = value          else:              _warn(f\"{elt_name}: apply[{k}] is not in the list of displayed columns.\")      styles = _get_name_indexed_property(attributes, \"style\")      for k, v in styles.items():  # pragma: no cover          if col_desc := _get_column_desc(columns, k):              if callable(v):                  value = hash_names.get(f\"style[{k}]\")              elif isinstance(v, str):                  value = v.strip()              else:                  value = None              if value in columns.keys():                  _warn(f\"{elt_name}: style[{k}]={value} cannot be a column's name.\")              elif value:                  col_desc[\"style\"] = value          else:              _warn(f\"{elt_name}: style[{k}] is not in the list of displayed columns.\")      tooltips = _get_name_indexed_property(attributes, \"tooltip\")      for k, v in tooltips.items():  # pragma: no cover          if col_desc := _get_column_desc(columns, k):              if callable(v):                  value = hash_names.get(f\"tooltip[{k}]\")              elif isinstance(v, str):                  value = v.strip()              else:                  value = None              if value in columns.keys():                  _warn(f\"{elt_name}: tooltip[{k}]={value} cannot be a column's name.\")              elif value:                  col_desc[\"tooltip\"] = value          else:              _warn(f\"{elt_name}: tooltip[{k}] is not in the list of displayed columns.\")      return columns "}
{"text": "import typing as t  from datetime import datetime  from random import random    from ..data.data_scope import _DataScopes  from ._map_dict import _MapDict    if t.TYPE_CHECKING:      from ..gui import Gui      class _Bindings:      def __init__(self, gui: \"Gui\") -> None:          self.__gui = gui          self.__scopes = _DataScopes()        def _bind(self, name: str, value: t.Any) -> None:          if hasattr(self, name):              raise ValueError(f\"Variable '{name}' is already bound\")          if not name.isidentifier():              raise ValueError(f\"Variable name '{name}' is invalid\")          if isinstance(value, dict):              setattr(self._get_data_scope(), name, _MapDict(value))          else:              setattr(self._get_data_scope(), name, value)          # prop = property(self.__value_getter(name), self.__value_setter(name))          setattr(_Bindings, name, self.__get_property(name))        def __get_property(self, name):          def __setter(ud: _Bindings, value: t.Any):              if isinstance(value, dict):                  value = _MapDict(value, None)              ud.__gui._update_var(name, value)            def __getter(ud: _Bindings) -> t.Any:              value = getattr(ud._get_data_scope(), name)              if isinstance(value, _MapDict):                  return _MapDict(value._dict, lambda k, v: ud.__gui._update_var(f\"{name}.{k}\", v))              else:                  return value            return property(__getter, __setter)  # Getter, Setter        def _set_single_client(self, value: bool) -> None:          self.__scopes.set_single_client(value)        def _is_single_client(self) -> bool:          return self.__scopes.is_single_client()        def _get_or_create_scope(self, id: str):          create = not id          if create:              id = f\"{datetime.now().strftime('%Y%m%d%H%M%S%f')}-{random()}\"              self.__gui._send_ws_id(id)          self.__scopes.create_scope(id)          return id, create        def _new_scopes(self):          self.__scopes = _DataScopes()        def _get_data_scope(self):          return self.__scopes.get_scope(self.__gui._get_client_id())        def _get_all_scopes(self):          return self.__scopes.get_all_scopes() "}
{"text": "import re  import typing as t  from types import FrameType    from ._locals_context import _LocalsContext  from .get_imported_var import _get_imported_var  from .get_module_name import _get_module_name_from_frame, _get_module_name_from_imported_var      class _VariableDirectory:      def __init__(self, locals_context: _LocalsContext):          self._locals_context = locals_context          self._default_module = \"\"          self._var_dir: t.Dict[str, t.Dict] = {}          self._var_head: t.Dict[str, t.List[t.Tuple[str, str]]] = {}          self._imported_var_dir: t.Dict[str, t.List[t.Tuple[str, str, str]]] = {}        def set_default(self, frame: FrameType) -> None:          self._default_module = _get_module_name_from_frame(frame)          self.add_frame(frame)        def add_frame(self, frame: t.Optional[FrameType]) -> None:          if frame is None:              return          module_name = _get_module_name_from_frame(frame)          if module_name not in self._imported_var_dir:              imported_var_list = _get_imported_var(frame)              self._imported_var_dir[module_name] = imported_var_list        def pre_process_module_import_all(self) -> None:          for imported_dir in self._imported_var_dir.values():              additional_var_list: t.List[t.Tuple[str, str, str]] = []              for name, asname, module in imported_dir:                  if name != \"*\" or asname != \"*\":                      continue                  if module not in self._locals_context._locals_map.keys():                      continue                  with self._locals_context.set_locals_context(module):                      additional_var_list.extend(                          (v, v, module) for v in self._locals_context.get_locals().keys() if not v.startswith(\"_\")                      )              imported_dir.extend(additional_var_list)        def process_imported_var(self) -> None:          self.pre_process_module_import_all()          default_imported_dir = self._imported_var_dir[self._default_module]          with self._locals_context.set_locals_context(self._default_module):              for name, asname, module in default_imported_dir:                  if name == \"*\" and asname == \"*\":                      continue                  imported_module_name = _get_module_name_from_imported_var(                      name, self._locals_context.get_locals().get(asname, None), module                  )                  temp_var_name = self.add_var(asname, self._default_module)                  self.add_var(name, imported_module_name, temp_var_name)            for k, v in self._imported_var_dir.items():              with self._locals_context.set_locals_context(k):                  for name, asname, module in v:                      if name == \"*\" and asname == \"*\":                          continue                      imported_module_name = _get_module_name_from_imported_var(                          name, self._locals_context.get_locals().get(asname, None), module                      )                      var_name = self.get_var(name, imported_module_name)                      var_asname = self.get_var(asname, k)                      if var_name is None and var_asname is None:                          temp_var_name = self.add_var(asname, k)                          self.add_var(name, imported_module_name, temp_var_name)                      elif var_name is not None:                          self.add_var(asname, k, var_name)                      else:                          self.add_var(name, imported_module_name, var_asname)        def add_var(self, name: str, module: t.Optional[str], var_name: t.Optional[str] = None) -> str:          if module is None:              module = self._default_module          if gv := self.get_var(name, module):              return gv          var_encode = _variable_encode(name, module) if module != self._default_module else name          if var_name is None:              var_name = var_encode          self.__add_var_head(name, module, var_name)          if var_encode != var_name:              var_name_decode, module_decode = _variable_decode(var_name)              if module_decode is None:                  module_decode = self._default_module              self.__add_var_head(var_name_decode, module_decode, var_encode)          if name not in self._var_dir:              self._var_dir[name] = {module: var_name}          else:              self._var_dir[name][module] = var_name          return var_name        def __add_var_head(self, name: str, module: str, var_head: str) -> None:          if var_head not in self._var_head:              self._var_head[var_head] = [(name, module)]          else:              self._var_head[var_head].append((name, module))        def get_var(self, name: str, module: str) -> t.Optional[str]:          if name in self._var_dir and module in self._var_dir[name]:              return self._var_dir[name][module]          return None      _MODULE_NAME_MAP: t.List[str] = []  _MODULE_ID = \"_TPMDL_\"  _RE_TPMDL_DECODE = re.compile(r\"(.*?)\" + _MODULE_ID + r\"(\\d+)$\")      def _variable_encode(var_name: str, module_name: t.Optional[str]):      if module_name is None:          return var_name      if module_name not in _MODULE_NAME_MAP:          _MODULE_NAME_MAP.append(module_name)      return f\"{var_name}{_MODULE_ID}{_MODULE_NAME_MAP.index(module_name)}\"      def _variable_decode(var_name: str):      from ._evaluator import _Evaluator        if result := _RE_TPMDL_DECODE.match(var_name):          return _Evaluator._expr_decode(str(result[1])), _MODULE_NAME_MAP[int(result[2])]      return _Evaluator._expr_decode(var_name), None      def _reset_name_map():      _MODULE_NAME_MAP.clear() "}
{"text": "from typing import Dict      class _Singleton(type):      _instances: Dict = {}        def __call__(self, *args, **kwargs):          if self not in self._instances:              self._instances[self] = super(_Singleton, self).__call__(*args, **kwargs)          return self._instances[self] "}
{"text": "import re    import pandas as pd      def _get_data_type(value):      if pd.api.types.is_bool_dtype(value):          return \"bool\"      elif pd.api.types.is_integer_dtype(value):          return \"int\"      elif pd.api.types.is_float_dtype(value):          return \"float\"      return re.match(r\"^<class '(.*\\.)?(.*?)(\\d\\d)?'>\", str(type(value))).group(2) "}
{"text": "import ast  import inspect  import typing as t  from types import FrameType      def _get_imported_var(frame: FrameType) -> t.List[t.Tuple[str, str, str]]:      st = ast.parse(inspect.getsource(frame))      var_list: t.List[t.Tuple[str, str, str]] = []      for node in ast.walk(st):          if isinstance(node, ast.ImportFrom):              # get the imported element as (name, asname, module)              # ex: from module1 import a as x --> (\"a\", \"x\", \"module1\")              var_list.extend(                  (                      child_node.name,                      child_node.asname if child_node.asname is not None else child_node.name,                      node.module or \"\",                  )                  for child_node in node.names              )      return var_list "}
{"text": "import re  import typing as t  from datetime import date, datetime, time    from dateutil import parser  from pytz import utc    from .._warnings import _warn      def _date_to_string(date_val: t.Union[datetime, date, time]) -> str:      if isinstance(date_val, datetime):          # return date.isoformat() + 'Z', if possible          try:              return date_val.astimezone(utc).isoformat()          except Exception as e:              # astimezone() fails on Windows for pre-epoch times              # See https://bugs.python.org/issue36759              _warn(\"Exception raised converting date to ISO 8601\", e)      return date_val.isoformat()      def _string_to_date(date_str: str) -> t.Union[datetime, date]:      # return datetime.strptime(date_str, '%Y-%m-%dT%H:%M:%S.%fZ')      # return datetime.fromisoformat(date_str)      date = parser.parse(date_str)      date_regex = r\"^[A-Z][a-z]{2} (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \\d{2} \\d{4}$\"      return date.date() if re.match(date_regex, date_str) else date "}
{"text": "from importlib import util      def _is_in_notebook():  # pragma: no cover      try:          if not util.find_spec(\"IPython\"):              return False            from IPython import get_ipython            ipython = get_ipython()            if ipython is None or \"IPKernelApp\" not in ipython.config:              return False      except (ImportError, AttributeError):          return False      return True "}
{"text": "import typing as t  from pathlib import Path      def _get_non_existent_file_path(dir_path: Path, file_name: str) -> Path:      if not file_name:          file_name = \"taipy_file.bin\"      file_path = dir_path / file_name      index = 0      file_stem = file_path.stem      file_suffix = file_path.suffix      while file_path.exists():          file_path = dir_path / f\"{file_stem}.{index}{file_suffix}\"          index += 1      return file_path "}
{"text": "import re  import typing as t    _RE_PD_TYPE = re.compile(r\"^([^\\s\\d\\[]+)(\\d+)(\\[(.*,\\s(\\S+))\\])?\")      def _get_date_col_str_name(columns: t.List[str], col: str) -> str:      suffix = \"_str\"      while col + suffix in columns:          suffix += \"_\"      return col + suffix "}
{"text": "import typing as t    import numpy  import pandas as pd    from ..gui import Gui  from .data_format import _DataFormat  from .pandas_data_accessor import _PandasDataAccessor      class _NumpyDataAccessor(_PandasDataAccessor):      __types = (numpy.ndarray,)        @staticmethod      def get_supported_classes() -> t.List[str]:          return [t.__name__ for t in _NumpyDataAccessor.__types]  # type: ignore        def __get_dataframe(self, value: t.Any) -> pd.DataFrame:          return pd.DataFrame(value)        def get_col_types(self, var_name: str, value: t.Any) -> t.Union[None, t.Dict[str, str]]:  # type: ignore          if isinstance(value, _NumpyDataAccessor.__types):  # type: ignore              return super().get_col_types(var_name, self.__get_dataframe(value))          return None        def get_data(  # noqa: C901          self, guiApp: Gui, var_name: str, value: t.Any, payload: t.Dict[str, t.Any], data_format: _DataFormat      ) -> t.Dict[str, t.Any]:          if isinstance(value, _NumpyDataAccessor.__types):  # type: ignore              return super().get_data(guiApp, var_name, self.__get_dataframe(value), payload, data_format)          return {} "}
{"text": "import typing as t    import pandas as pd    from ..gui import Gui  from ..utils import _MapDict  from .data_format import _DataFormat  from .pandas_data_accessor import _PandasDataAccessor      class _ArrayDictDataAccessor(_PandasDataAccessor):      __types = (dict, list, tuple, _MapDict)        @staticmethod      def get_supported_classes() -> t.List[str]:          return [t.__name__ for t in _ArrayDictDataAccessor.__types]  # type: ignore        def __get_dataframe(self, value: t.Any) -> t.Union[t.List[pd.DataFrame], pd.DataFrame]:          if isinstance(value, list):              if not value or isinstance(value[0], (str, int, float, bool)):                  return pd.DataFrame({\"0\": value})              types = {type(x) for x in value}              if len(types) == 1:                  type_elt = next(iter(types), None)                  if type_elt == list:                      lengths = {len(x) for x in value}                      return (                          pd.DataFrame(value)                          if len(lengths) == 1                          else [pd.DataFrame({f\"{i}/0\": v}) for i, v in enumerate(value)]                      )                  elif type_elt == dict:                      return [pd.DataFrame(v) for v in value]                  elif type_elt == _MapDict:                      return [pd.DataFrame(v._dict) for v in value]                  elif type_elt == pd.DataFrame:                      return value                elif len(types) == 2 and list in types and pd.DataFrame in types:                  return [v if isinstance(v, pd.DataFrame) else pd.DataFrame({f\"{i}/0\": v}) for i, v in enumerate(value)]          elif isinstance(value, _MapDict):              return pd.DataFrame(value._dict)          return pd.DataFrame(value)        def get_col_types(self, var_name: str, value: t.Any) -> t.Union[None, t.Dict[str, str]]:  # type: ignore          if isinstance(value, _ArrayDictDataAccessor.__types):  # type: ignore              return super().get_col_types(var_name, self.__get_dataframe(value))          return None        def get_data(  # noqa: C901          self, guiApp: Gui, var_name: str, value: t.Any, payload: t.Dict[str, t.Any], data_format: _DataFormat      ) -> t.Dict[str, t.Any]:          if isinstance(value, _ArrayDictDataAccessor.__types):  # type: ignore              return super().get_data(guiApp, var_name, self.__get_dataframe(value), payload, data_format)          return {} "}
{"text": "from .data_accessor import _DataAccessor  from .decimator import LTTB, RDP, MinMaxDecimator, ScatterDecimator  from .utils import Decimator "}
{"text": "import inspect  import typing as t  from abc import ABC, abstractmethod    from .._warnings import _warn  from ..utils import _TaipyData  from .data_format import _DataFormat      class _DataAccessor(ABC):      _WS_DATE_FORMAT = \"%Y-%m-%dT%H:%M:%S.%fZ\"        @staticmethod      @abstractmethod      def get_supported_classes() -> t.List[str]:          pass        @abstractmethod      def get_data(          self, guiApp: t.Any, var_name: str, value: t.Any, payload: t.Dict[str, t.Any], data_format: _DataFormat      ) -> t.Dict[str, t.Any]:          pass        @abstractmethod      def get_col_types(self, var_name: str, value: t.Any) -> t.Dict[str, str]:          pass      class _InvalidDataAccessor(_DataAccessor):      @staticmethod      def get_supported_classes() -> t.List[str]:          return [type(None).__name__]        def get_data(          self, guiApp: t.Any, var_name: str, value: t.Any, payload: t.Dict[str, t.Any], data_format: _DataFormat      ) -> t.Dict[str, t.Any]:          return {}        def get_col_types(self, var_name: str, value: t.Any) -> t.Dict[str, str]:          return {}      class _DataAccessors(object):      def __init__(self) -> None:          self.__access_4_type: t.Dict[str, _DataAccessor] = {}            self.__invalid_data_accessor = _InvalidDataAccessor()            self.__data_format = _DataFormat.JSON            from .array_dict_data_accessor import _ArrayDictDataAccessor          from .numpy_data_accessor import _NumpyDataAccessor          from .pandas_data_accessor import _PandasDataAccessor            self._register(_PandasDataAccessor)          self._register(_ArrayDictDataAccessor)          self._register(_NumpyDataAccessor)        def _register(self, cls: t.Type[_DataAccessor]) -> None:          if not inspect.isclass(cls):              raise AttributeError(\"The argument of 'DataAccessors.register' should be a class\")          if not issubclass(cls, _DataAccessor):              raise TypeError(f\"Class {cls.__name__} is not a subclass of DataAccessor\")          names = cls.get_supported_classes()          if not names:              raise TypeError(f\"method {cls.__name__}.get_supported_classes returned an invalid value\")          # check existence          inst: t.Optional[_DataAccessor] = None          for name in names:              inst = self.__access_4_type.get(name)              if inst:                  break          if inst is None:              try:                  inst = cls()              except Exception as e:                  raise TypeError(f\"Class {cls.__name__} cannot be instanciated\") from e              if inst:                  for name in names:                      self.__access_4_type[name] = inst  # type: ignore        def __get_instance(self, value: _TaipyData) -> _DataAccessor:  # type: ignore          value = value.get()          access = self.__access_4_type.get(type(value).__name__)          if access is None:              _warn(f\"Can't find Data Accessor for type {type(value).__name__}.\")              return self.__invalid_data_accessor          return access        def _get_data(          self, guiApp: t.Any, var_name: str, value: _TaipyData, payload: t.Dict[str, t.Any]      ) -> t.Dict[str, t.Any]:          return self.__get_instance(value).get_data(guiApp, var_name, value.get(), payload, self.__data_format)        def _get_col_types(self, var_name: str, value: _TaipyData) -> t.Dict[str, str]:          return self.__get_instance(value).get_col_types(var_name, value.get())        def _set_data_format(self, data_format: _DataFormat):          self.__data_format = data_format "}
{"text": "from __future__ import annotations    import typing as t  from abc import ABC, abstractmethod    import numpy as np    from .._warnings import _warn    if t.TYPE_CHECKING:      import pandas as pd      class Decimator(ABC):      \"\"\"Base class for decimating chart data.        *Decimating* is the term used to name the process of reducing the number of      data points displayed in charts while retaining the overall shape of the traces.      `Decimator` is a base class that does decimation on data sets.        Taipy GUI comes out-of-the-box with several implementation of this class for      different use cases.      \"\"\"        _CHART_MODES: t.List[str] = []        def __init__(self, threshold: t.Optional[int], zoom: t.Optional[bool]) -> None:          \"\"\"Initialize a new `Decimator`.            Arguments:              threshold (Optional[int]): The minimum amount of data points before the                  decimator class is applied.              zoom (Optional[bool]): set to True to reapply the decimation                  when zoom or re-layout events are triggered.          \"\"\"          super().__init__()          self.threshold = threshold          self._zoom = zoom if zoom is not None else True        def _is_applicable(self, data: t.Any, nb_rows_max: int, chart_mode: str):          if chart_mode not in self._CHART_MODES:              _warn(f\"{type(self).__name__} is only applicable for {' '.join(self._CHART_MODES)}.\")              return False          if self.threshold is None:              if nb_rows_max < len(data):                  return True          elif self.threshold < len(data):              return True          return False        @abstractmethod      def decimate(self, data: np.ndarray, payload: t.Dict[str, t.Any]) -> np.ndarray:          \"\"\"Decimate function.            This method is executed when the appropriate conditions specified in the          constructor are met. This function implements the algorithm that determines          which data points are kept or dropped.            Arguments:              data (numpy.array): An array containing all the data points represented as                  tuples.              payload (Dict[str, any]): additional information on charts that is provided                  at runtime.            Returns:              An array of Boolean mask values. The array should set True or False for each                  of its indexes where True indicates that the corresponding data point                  from *data* should be preserved, or False requires that this                  data point be dropped.          \"\"\"          return NotImplementedError  # type: ignore      def _df_data_filter(      dataframe: pd.DataFrame,      x_column_name: t.Optional[str],      y_column_name: str,      z_column_name: str,      decimator: Decimator,      payload: t.Dict[str, t.Any],      is_copied: bool,  ):      df = dataframe.copy() if not is_copied else dataframe      if not x_column_name:          index = 0          while f\"tAiPy_index_{index}\" in df.columns:              index += 1          x_column_name = f\"tAiPy_index_{index}\"          df[x_column_name] = df.index      column_list = [x_column_name, y_column_name, z_column_name] if z_column_name else [x_column_name, y_column_name]      points = df[column_list].to_numpy()      mask = decimator.decimate(points, payload)      return df[mask], is_copied      def _df_relayout(      dataframe: pd.DataFrame,      x_column: t.Optional[str],      y_column: str,      chart_mode: str,      x0: t.Optional[float],      x1: t.Optional[float],      y0: t.Optional[float],      y1: t.Optional[float],      is_copied: bool,  ):      if chart_mode not in [\"lines+markers\", \"markers\"]:          return dataframe, is_copied      # if chart data is invalid      if x0 is None or x1 is None or y0 is None or y1 is None:          return dataframe, is_copied      df = dataframe.copy() if not is_copied else dataframe      is_copied = True      has_x_col = True        if not x_column:          index = 0          while f\"tAiPy_index_{index}\" in df.columns:              index += 1          x_column = f\"tAiPy_index_{index}\"          df[x_column] = df.index          has_x_col = False        # if chart_mode is empty      if chart_mode == \"lines+markers\":          # only filter by x column          df = df.loc[(df[x_column] > x0) & (df[x_column] < x1)]      else:          # filter by both x and y columns          df = df.loc[(df[x_column] > x0) & (df[x_column] < x1) & (df[y_column] > y0) & (df[y_column] < y1)]  # noqa      if not has_x_col:          df.drop(x_column, axis=1, inplace=True)      return df, is_copied "}
{"text": "from enum import Enum      class _DataFormat(Enum):      JSON = \"JSON\"      APACHE_ARROW = \"ARROW\" "}
{"text": "import base64  import pathlib  import tempfile  import typing as t  import urllib.parse  from importlib import util  from pathlib import Path  from sys import getsizeof    from .._warnings import _warn  from ..utils import _get_non_existent_file_path, _variable_decode    _has_magic_module = False    if util.find_spec(\"magic\"):      import magic        _has_magic_module = True      class _ContentAccessor:      def __init__(self, data_url_max_size: int) -> None:          self.__content_paths: t.Dict[str, pathlib.Path] = {}          self.__url_is_image: t.Dict[str, bool] = {}          self.__paths: t.Dict[pathlib.Path, str] = {}          self.__data_url_max_size = data_url_max_size          self.__temp_dir_path = Path(tempfile.gettempdir())        def get_path(self, path: pathlib.Path) -> str:          url_path = self.__paths.get(path)          if url_path is None:              self.__paths[path] = url_path = \"taipyStatic\" + str(len(self.__paths))          return url_path        def get_content_path(          self, url_path: str, file_name: str, bypass: t.Optional[str]      ) -> t.Tuple[t.Union[pathlib.Path, None], bool]:          content_path = self.__content_paths.get(url_path)          if not content_path:              return (None, True)          return (content_path, bypass is not None or self.__url_is_image.get(f\"{url_path}/{file_name}\", False))        def __get_mime_from_file(self, path: pathlib.Path):          if _has_magic_module:              try:                  return magic.from_file(str(path), mime=True)              except Exception as e:                  _warn(f\"Exception reading mime type in '{path}'\", e)          return None        def __get_display_name(self, var_name: str) -> str:          if not isinstance(var_name, str):              return var_name          if var_name.startswith(\"_tpC_\"):              var_name = var_name[5:]          if var_name.startswith(\"tpec_\"):              var_name = var_name[5:]          return _variable_decode(var_name)[0]        def get_info(self, var_name: str, value: t.Any, image: bool) -> t.Union[str, t.Tuple[str], t.Any]:  # noqa: C901          if value is None:              return \"\"          newvalue = value          mime = None          if not isinstance(newvalue, (str, pathlib.Path)) and (              getsizeof(newvalue) > self.__data_url_max_size or not _has_magic_module          ):              # write data to file              file_name = \"TaiPyContent.bin\"              if _has_magic_module:                  try:                      mime = magic.from_buffer(value, mime=True)                      file_name = \"TaiPyContent.\" + mime.split(\"/\")[-1]                  except Exception as e:                      _warn(f\"{self.__get_display_name(var_name)} ({type(value)}) cannot be typed\", e)              file_path = _get_non_existent_file_path(self.__temp_dir_path, file_name)              try:                  with open(file_path, \"wb\") as temp_file:                      temp_file.write(value)              except Exception as e:                  _warn(f\"{self.__get_display_name(var_name)} ({type(value)}) cannot be written to file {file_path}\", e)              newvalue = file_path          if isinstance(newvalue, (str, pathlib.Path)):              path = pathlib.Path(newvalue) if isinstance(newvalue, str) else newvalue              if not path.is_file():                  if (                      var_name != \"Gui.download\"                      and not str(path).startswith(\"http\")                      and not str(path).startswith(\"/\")                      and not str(path).strip().lower().startswith(\"<svg\")                  ):                      _warn(f\"{self.__get_display_name(var_name)}: file '{value}' does not exist.\")                  return str(value)              if image:                  if not mime:                      mime = self.__get_mime_from_file(path)                  if mime and not mime.startswith(\"image\"):                      _warn(f\"{self.__get_display_name(var_name)}: file '{path}' mime type ({mime}) is not an image.\")                      return f\"Invalid content: {mime}\"              dir_path = path.resolve().parent              url_path = self.get_path(dir_path)              self.__content_paths[url_path] = dir_path              file_url = f\"{url_path}/{path.name}\"              self.__url_is_image[file_url] = image              return (urllib.parse.quote_plus(file_url, safe=\"/\"),)          elif _has_magic_module:              try:                  mime = magic.from_buffer(value, mime=True)                  if not image or mime.startswith(\"image\"):                      return f\"data:{mime};base64,\" + str(base64.b64encode(value), \"utf-8\")                  _warn(f\"{self.__get_display_name(var_name)}: ({type(value)}) does not have an image mime type: {mime}.\")                  return f\"Invalid content: {mime}\"              except Exception as e:                  _warn(f\"{self.__get_display_name(var_name)}: ({type(value)}) cannot be base64 encoded\", e)                  return \"Cannot be base64 encoded\"          else:              _warn(                  \"python-magic (and python-magic-bin on Windows) packages need to be installed if you want to process content as an array of bytes.\"              )              return \"Cannot guess content type\" "}
{"text": "from __future__ import annotations    import typing as t  from types import SimpleNamespace    from .._warnings import _warn      class _DataScopes:      _GLOBAL_ID = \"global\"        def __init__(self) -> None:          self.__scopes: t.Dict[str, SimpleNamespace] = {_DataScopes._GLOBAL_ID: SimpleNamespace()}          self.__single_client = True        def set_single_client(self, value: bool) -> None:          self.__single_client = value        def is_single_client(self) -> bool:          return self.__single_client        def get_scope(self, client_id: t.Optional[str]) -> SimpleNamespace:          if self.__single_client:              return self.__scopes[_DataScopes._GLOBAL_ID]          # global context in case request is not registered or client_id is not available (such as in the context of running tests)          if not client_id:              _warn(\"Empty session id, using global scope instead.\")              return self.__scopes[_DataScopes._GLOBAL_ID]          if client_id not in self.__scopes:              _warn(                  f\"Session id {client_id} not found in data scope. Taipy will automatically create a scope for this session id but you may have to reload your page.\"              )              self.create_scope(client_id)          return self.__scopes[client_id]        def get_all_scopes(self) -> t.Dict[str, SimpleNamespace]:          return self.__scopes        def create_scope(self, id: str) -> None:          if self.__single_client:              return          if id is None:              _warn(\"Empty session id, might be due to unestablished WebSocket connection.\")              return          if id not in self.__scopes:              self.__scopes[id] = SimpleNamespace()        def delete_scope(self, id: str) -> None:  # pragma: no cover          if self.__single_client:              return          if id is None:              _warn(\"Empty session id, might be due to unestablished WebSocket connection.\")              return          if id in self.__scopes:              del self.__scopes[id] "}
{"text": "import typing as t    import numpy as np    from ..utils import Decimator      class ScatterDecimator(Decimator):      \"\"\"A decimator designed for scatter charts.        This algorithm fits the data points into a grid. If multiple points are in the same grid      cell, depending on the chart configuration, some points are removed to reduce the number      points being displayed.        This class can only be used with scatter charts.      \"\"\"        _CHART_MODES = [\"markers\"]        def __init__(          self,          binning_ratio: t.Optional[float] = None,          max_overlap_points: t.Optional[int] = None,          threshold: t.Optional[int] = None,          zoom: t.Optional[bool] = True,      ):          \"\"\"Initialize a new `ScatterDecimator`.            Arguments:              binning_ratio (Optional[float]): the size of the data grid for the algorithm.                  The higher the value, the smaller the grid size.              max_overlap_points (Optional(int)): the maximum number of points for a single cell                  within the data grid within the algorithm. This dictates how dense a single                  grid cell can be.              threshold (Optional[int]): The minimum amount of data points before the                  decimation is applied.              zoom (Optional[bool]): set to True to reapply the decimation                  when zoom or re-layout events are triggered.          \"\"\"          super().__init__(threshold, zoom)          binning_ratio = binning_ratio if binning_ratio is not None else 1          self._binning_ratio = binning_ratio if binning_ratio > 0 else 1          self._max_overlap_points = max_overlap_points if max_overlap_points is not None else 3        def decimate(self, data: np.ndarray, payload: t.Dict[str, t.Any]) -> np.ndarray:          n_rows = data.shape[0]          mask = np.empty(n_rows, dtype=bool)          width = payload.get(\"width\", None)          height = payload.get(\"height\", None)          if width is None or height is None:              mask.fill(True)              return mask          mask.fill(False)          grid_x, grid_y = round(width / self._binning_ratio), round(height / self._binning_ratio)          x_col, y_col = data[:, 0], data[:, 1]          min_x, max_x = np.amin(x_col), np.amax(x_col)          min_y, max_y = np.amin(y_col), np.amax(y_col)          min_max_x_diff, min_max_y_diff = max_x - min_x, max_y - min_y          x_grid_map = np.rint((x_col - min_x) * grid_x / min_max_x_diff).astype(int)          y_grid_map = np.rint((y_col - min_y) * grid_y / min_max_y_diff).astype(int)          z_grid_map = None          grid_shape = (grid_x + 1, grid_y + 1)          if len(data[0]) == 3:              grid_z = grid_x              grid_shape = (grid_x + 1, grid_y + 1, grid_z + 1)  # type: ignore              z_col = data[:, 2]              min_z, max_z = np.amin(z_col), np.amax(z_col)              min_max_z_diff = max_z - min_z              z_grid_map = np.rint((z_col - min_z) * grid_z / min_max_z_diff).astype(int)          grid = np.empty(grid_shape, dtype=int)          grid.fill(0)          if z_grid_map is not None:              for i in np.arange(n_rows):                  if grid[x_grid_map[i], y_grid_map[i], z_grid_map[i]] < self._max_overlap_points:                      grid[x_grid_map[i], y_grid_map[i], z_grid_map[i]] += 1                      mask[i] = True          else:              for i in np.arange(n_rows):                  if grid[x_grid_map[i], y_grid_map[i]] < self._max_overlap_points:                      grid[x_grid_map[i], y_grid_map[i]] += 1                      mask[i] = True          return mask "}
{"text": "from .lttb import LTTB  from .minmax import MinMaxDecimator  from .rdp import RDP  from .scatter_decimator import ScatterDecimator "}
{"text": "import typing as t    import numpy as np    from ..utils import Decimator      class MinMaxDecimator(Decimator):      \"\"\"A decimator using the MinMax algorithm.        The MinMax algorithm is an efficient algorithm that preserves the peaks within the data. It      can work very well with noisy signal data where data peeks need to be highlighted.        This class can only be used with line charts.      \"\"\"        _CHART_MODES = [\"lines+markers\"]        def __init__(self, n_out: int, threshold: t.Optional[int] = None, zoom: t.Optional[bool] = True):          \"\"\"Initialize a new `MinMaxDecimator`.            Arguments:              n_out (int): The maximum number of points that will be displayed after decimation.              threshold (Optional[int]): The minimum amount of data points before the                  decimation is applied.              zoom (Optional[bool]): set to True to reapply the decimation                  when zoom or re-layout events are triggered.          \"\"\"          super().__init__(threshold, zoom)          self._n_out = n_out // 2        def decimate(self, data: np.ndarray, payload: t.Dict[str, t.Any]) -> np.ndarray:          if self._n_out >= data.shape[0]:              return np.full(len(data), False)          # Create a boolean mask          x = data[:, 0]          y = data[:, 1]          num_bins = self._n_out          pts_per_bin = x.size // num_bins          # Create temp to hold the reshaped & slightly cropped y          y_temp = y[: num_bins * pts_per_bin].reshape((num_bins, pts_per_bin))          # use argmax/min to get column locations          cc_max = np.argmax(y_temp, axis=1)          cc_min = np.argmin(y_temp, axis=1)          rr = np.arange(0, num_bins)          # compute the flat index to where these are          flat_max = cc_max + rr * pts_per_bin          flat_min = cc_min + rr * pts_per_bin          mm_mask = np.full((x.size,), False)          mm_mask[flat_max] = True          mm_mask[flat_min] = True          return mm_mask "}
{"text": "import typing as t    import numpy as np    from ..utils import Decimator      class LTTB(Decimator):      \"\"\"A decimator using the LTTB algorithm.        The LTTB algorithm is an high performance algorithm that significantly reduces the number of      data points. It can work very well with time-series data to show trends using by using only      a few data points.        This class can only be used with line charts.      \"\"\"        _CHART_MODES = [\"lines+markers\"]        def __init__(self, n_out: int, threshold: t.Optional[int] = None, zoom: t.Optional[bool] = True) -> None:          \"\"\"Initialize a new `LTTB`.            Arguments:              n_out (int): The maximum number of points that will be displayed after decimation.              threshold (Optional[int]): The minimum amount of data points before the                  decimation is applied.              zoom (Optional[bool]): set to True to reapply the decimation                  when zoom or re-layout events are triggered.          \"\"\"          super().__init__(threshold, zoom)          self._n_out = n_out        @staticmethod      def _areas_of_triangles(a, bs, c):          bs_minus_a = bs - a          a_minus_bs = a - bs          return 0.5 * abs((a[0] - c[0]) * (bs_minus_a[:, 1]) - (a_minus_bs[:, 0]) * (c[1] - a[1]))        def decimate(self, data: np.ndarray, payload: t.Dict[str, t.Any]) -> np.ndarray:          n_out = self._n_out          if n_out >= data.shape[0]:              return np.full(len(data), True)            if n_out < 3:              raise ValueError(\"Can only down-sample to a minimum of 3 points\")            # Split data into bins          n_bins = n_out - 2          data_bins = np.array_split(data[1:-1], n_bins)            prev_a = data[0]          start_pos = 0            # Prepare output mask array          # First and last points are the same as in the input.          out_mask = np.full(len(data), False)          out_mask[0] = True          out_mask[len(data) - 1] = True            # Largest Triangle Three Buckets (LTTB):          # In each bin, find the point that makes the largest triangle          # with the point saved in the previous bin          # and the centroid of the points in the next bin.          for i in range(len(data_bins)):              this_bin = data_bins[i]              next_bin = data_bins[i + 1] if i < n_bins - 1 else data[-1:]              a = prev_a              bs = this_bin              c = next_bin.mean(axis=0)                areas = LTTB._areas_of_triangles(a, bs, c)              bs_pos = np.argmax(areas)              prev_a = bs[bs_pos]              out_mask[start_pos + bs_pos] = True              start_pos += len(this_bin)            return out_mask "}
{"text": "import typing as t    import numpy as np    from ..utils import Decimator      class RDP(Decimator):      \"\"\"A decimator using the RDP algorithm.        The RDP algorithm reduces a shape made of line segments into a similar shape with      less points. This algorithm should be used if the final visual representation is      prioritized over the performance of the application.        This class can only be used with line charts.      \"\"\"        _CHART_MODES = [\"lines+markers\"]        def __init__(          self,          epsilon: t.Optional[int] = None,          n_out: t.Optional[int] = None,          threshold: t.Optional[int] = None,          zoom: t.Optional[bool] = True,      ):          \"\"\"Initialize a new `RDP`.            Arguments:              epsilon (Optional[int]): The epsilon value for the RDP algorithm. If this value                  is being used, the *n_out* argument is ignored.              n_out (Optional(int)): The maximum number of points that are displayed after                  decimation. This value is ignored if the epsilon value is used.<br/>                  This process is not very efficient so consider using `LTTB` or `MinMaxDecimator`                  if the provided data has more than 100.000 data points.              threshold (Optional[int]): The minimum amount of data points before the                  decimation is applied.              zoom (Optional[bool]): set to True to reapply the decimation                  when zoom or re-layout events are triggered.          \"\"\"          super().__init__(threshold, zoom)          self._epsilon = epsilon          self._n_out = n_out        @staticmethod      def dsquared_line_points(P1, P2, points):          \"\"\"          Calculate only squared distance, only needed for comparison          \"\"\"          xdiff = P2[0] - P1[0]          ydiff = P2[1] - P1[1]          nom = (ydiff * points[:, 0] - xdiff * points[:, 1] + P2[0] * P1[1] - P2[1] * P1[0]) ** 2          denom = ydiff**2 + xdiff**2          return np.divide(nom, denom)        @staticmethod      def __rdp_epsilon(data, epsilon: int):          # initiate mask array          # same amount of points          mask = np.empty(data.shape[0], dtype=bool)            # Assume all points are valid and falsify those which are found          mask.fill(True)            # The stack to select start and end index          stack: t.List[t.Tuple[int, int]] = [(0, data.shape[0] - 1)]  # type: ignore            while stack:              # Pop the last item              (start, end) = stack.pop()                # nothing to calculate if no points in between              if end - start <= 1:                  continue                # Calculate distance to points              P1 = data[start]              P2 = data[end]              points = data[start + 1 : end]              dsq = RDP.dsquared_line_points(P1, P2, points)                mask_eps = dsq > epsilon**2                if mask_eps.any():                  # max point outside eps                  # Include index that was sliced out                  # Also include the start index to get absolute index                  # And not relative                  mid = np.argmax(dsq) + 1 + start                  stack.append((start, mid))  # type: ignore                  stack.append((mid, end))  # type: ignore                else:                  # Points in between are redundant                  mask[start + 1 : end] = False            return mask        @staticmethod      def __rdp_points(M, n_out):          M_len = M.shape[0]            if M_len <= n_out:              mask = np.empty(M_len, dtype=bool)              mask.fill(True)              return mask            weights = np.empty(M_len)          # weights.fill(0)          weights[0] = float(\"inf\")          weights[M_len - 1] = float(\"inf\")            stack = [(0, M_len - 1)]            while stack:              (start, end) = stack.pop()              if end - start <= 1:                  continue              dsq = RDP.dsquared_line_points(M[start], M[end], M[start + 1 : end])              max_dist_index = np.argmax(dsq) + start + 1              weights[max_dist_index] = np.amax(dsq)              stack.append((start, max_dist_index))              stack.append((max_dist_index, end))            maxTolerance = np.sort(weights)[M_len - n_out]            return weights >= maxTolerance        def decimate(self, data: np.ndarray, payload: t.Dict[str, t.Any]) -> np.ndarray:          if self._epsilon:              return RDP.__rdp_epsilon(data, self._epsilon)          elif self._n_out:              return RDP.__rdp_points(data, self._n_out)          raise RuntimeError(\"RDP Decimator failed to run. Fill in either 'epsilon' or 'n_out' value\") "}
{"text": "import typing as t    from ..utils.singleton import _Singleton    if t.TYPE_CHECKING:      from ._element import _Block      class _BuilderContextManager(object, metaclass=_Singleton):      def __init__(self):          self.__blocks: t.List[\"_Block\"] = []        def push(self, element: \"_Block\") -> None:          self.__blocks.append(element)        def pop(self) -> t.Optional[\"_Block\"]:          return self.__blocks.pop() if self.__blocks else None        def peek(self) -> t.Optional[\"_Block\"]:          return self.__blocks[-1] if self.__blocks else None "}
{"text": "from ._api_generator import _ElementApiGenerator  from ._element import html    # separate import for \"Page\" class so stubgen can properly generate pyi file  from .page import Page    _ElementApiGenerator().add_default() "}
{"text": "import typing as t    from .._renderers import _Renderer  from ._context_manager import _BuilderContextManager  from ._element import _Block, _DefaultBlock, _Element      class Page(_Renderer):      \"\"\"Page generator for the Builder API.        This class is used to create a page created with the Builder API.<br/>      Instance of this class can be added to the application using `Gui.add_page()^`.        This class is typically be used as a Python Context Manager to add the elements.<br/>      Here is how you can create a single-page application, creating the elements with code:      ```py      from taipy.gui import Gui      from taipy.gui.builder import Page, button        def do_something(state):          pass        with Page() as page:          button(label=\"Press me\", on_action=do_something)        Gui(page).run()      ```      \"\"\"        def __init__(self, element: t.Optional[_Element] = None, **kwargs) -> None:          \"\"\"Initialize a new page.            Arguments:              element (*Element*): An optional element, defined in the `taipy.gui.builder` module,                  that is created in the page.<br/>                  The default creates a `part` where several elements can be stored.          \"\"\"          if element is None:              element = _DefaultBlock()          kwargs[\"content\"] = element          super().__init__(**kwargs)        # Generate JSX from Element Object      def render(self, gui) -> str:          if self._base_element is None:              return \"<h1>No Base Element found for Page</h1>\"          return self._base_element._render(gui)        def add(self, *elements: _Element):          if not isinstance(self._base_element, _Block):              raise RuntimeError(\"Can't add child element to non-block element\")          for element in elements:              if element not in self._base_element._children:                  self._base_element._children.append(element)          return self        def __enter__(self):          if self._base_element is None:              raise RuntimeError(\"Can't use context manager with missing block element for Page\")          if not isinstance(self._base_element, _Block):              raise RuntimeError(\"Can't add child element to non-block element\")          _BuilderContextManager().push(self._base_element)          return self        def __exit__(self, exc_type, exc_value, traceback):          _BuilderContextManager().pop() "}
{"text": "import typing as t    from .._renderers.factory import _Factory      class _BuilderFactory(_Factory):      @staticmethod      def create_element(gui, element_type: str, properties: t.Dict[str, t.Any]) -> t.Tuple[str, str]:          builder_html = _Factory.call_builder(gui, element_type, properties, True)          if builder_html is None:              return f\"<div>INVALID SYNTAX - Element is '{element_type}'\", \"div\"          return builder_html  # type: ignore "}
{"text": "from __future__ import annotations    import copy  import typing as t  from abc import ABC, abstractmethod  from collections.abc import Iterable    from ._context_manager import _BuilderContextManager  from ._factory import _BuilderFactory    if t.TYPE_CHECKING:      from ..gui import Gui      class _Element(ABC):      \"\"\"NOT DOCUMENTED\"\"\"        _ELEMENT_NAME = \"\"      _DEFAULT_PROPERTY = \"\"        def __new__(cls, *args, **kwargs):          obj = super(_Element, cls).__new__(cls)          parent = _BuilderContextManager().peek()          if parent is not None:              parent.add(obj)          return obj        def __init__(self, *args, **kwargs):          self._properties: t.Dict[str, t.Any] = {}          if args and self._DEFAULT_PROPERTY != \"\":              self._properties = {self._DEFAULT_PROPERTY: args[0]}          self._properties.update(kwargs)          self.parse_properties()        def update(self, **kwargs):          self._properties.update(kwargs)          self.parse_properties()        # Convert property value to string      def parse_properties(self):          self._properties = {k: _Element._parse_property(v) for k, v in self._properties.items()}        # Get a deepcopy version of the properties      def _deepcopy_properties(self):          return copy.deepcopy(self._properties)        @staticmethod      def _parse_property(value: t.Any) -> t.Any:          if isinstance(value, (str, dict, Iterable)):              return value          if hasattr(value, \"__name__\"):              return str(getattr(value, \"__name__\"))          return str(value)        @abstractmethod      def _render(self, gui: \"Gui\") -> str:          pass      class _Block(_Element):      \"\"\"NOT DOCUMENTED\"\"\"        def __init__(self, *args, **kwargs):          super().__init__(*args, **kwargs)          self._children: t.List[_Element] = []        def add(self, *elements: _Element):          for element in elements:              if element not in self._children:                  self._children.append(element)          return self        def __enter__(self):          _BuilderContextManager().push(self)          return self        def __exit__(self, exc_type, exc_value, traceback):          _BuilderContextManager().pop()        def _render(self, gui: \"Gui\") -> str:          el = _BuilderFactory.create_element(gui, self._ELEMENT_NAME, self._deepcopy_properties())          return f\"{el[0]}{self._render_children(gui)}</{el[1]}>\"        def _render_children(self, gui: \"Gui\") -> str:          return \"\\n\".join([child._render(gui) for child in self._children])      class _DefaultBlock(_Block):      _ELEMENT_NAME = \"part\"        def __init__(self, *args, **kwargs):          super().__init__(*args, **kwargs)      class html(_Block):      \"\"\"A visual element defined as an HTML tag.        Use this class to integrate raw HTML to your page.        This element can be used as a block element.      \"\"\"        def __init__(self, *args, **kwargs):          \"\"\"Create a new `html` block.            Arguments:              args (any[]): A list of one or two unnamed arguments:                    - *args[0]* is the HTML tag name. If empty or None, this represents an HTML text                    node.                  - *args[1]* (optional) is the text of this element.<br/>                    Note that special HTML characters (such as '&lt;' or '&amp;') do not need to be protected.              kwargs (dict[str, any]): the HTML attributes for this element.<br/>                  These should be valid attribute names, with valid attribute values.            Examples:              - To generate `<br/>`, use:                 ```                 html(\"br\")                 ```              - To generate `<h1>My page title</h1>`, use:                 ```                 html(\"h1\", \"My page title\")                 ```              - To generate `<h1 id=\"page-title\">My page title</h1>`, use:                 ```                 html(\"h1\", \"My page title\", id=\"page-title\")                 ```              - To generate `<p>This is a <b>Taipy GUI</b> element.</p>`, use:                 ```                 with html(\"p\"):                     html(None, \"This is a \")                     html(\"b\", \"Taipy GUI\")                     html(None, \" element.\")                 ```          \"\"\"          super().__init__(*args, **kwargs)          if not args:              raise RuntimeError(\"Can't render html element. Missing html tag name.\")          self._ELEMENT_NAME = args[0] if args[0] else None          self._content = args[1] if len(args) > 1 else \"\"        def _render(self, gui: \"Gui\") -> str:          if self._ELEMENT_NAME:              attrs = \"\"              if self._properties:                  attrs = \" \" + \" \".join([f'{k}=\"{str(v)}\"' for k, v in self._properties.items()])              return f\"<{self._ELEMENT_NAME}{attrs}>{self._content}{self._render_children(gui)}</{self._ELEMENT_NAME}>\"          else:              return self._content      class _Control(_Element):      \"\"\"NOT DOCUMENTED\"\"\"        def __init__(self, *args, **kwargs):          super().__init__(*args, **kwargs)        def _render(self, gui: \"Gui\") -> str:          el = _BuilderFactory.create_element(gui, self._ELEMENT_NAME, self._deepcopy_properties())          return (              f\"<div>{el[0]}</{el[1]}></div>\"              if f\"<{el[1]}\" in el[0] and f\"</{el[1]}\" not in el[0]              else f\"<div>{el[0]}</div>\"          )        def __enter__(self):          raise RuntimeError(f\"Can't use Context Manager for control type '{self._ELEMENT_NAME}'\")        def __exit__(self, exc_type, exc_value, traceback):          raise RuntimeError(f\"Can't use Context Manager for control type '{self._ELEMENT_NAME}'\") "}
{"text": "import inspect  import json  import os  import sys  import types  import typing as t    from taipy.logger._taipy_logger import _TaipyLogger    from ..utils.singleton import _Singleton  from ._element import _Block, _Control    if t.TYPE_CHECKING:      from ..extension.library import ElementLibrary      class _ElementApiGenerator(object, metaclass=_Singleton):      def __init__(self):          self.__module: t.Optional[types.ModuleType] = None        @staticmethod      def find_default_property(property_list: t.List[t.Dict[str, t.Any]]) -> str:          for property in property_list:              if \"default_property\" in property and property[\"default_property\"] is True:                  return property[\"name\"]          return \"\"        def add_default(self):          current_frame = inspect.currentframe()          error_message = \"Cannot generate elements API for the current module\"          if current_frame is None:              raise RuntimeError(f\"{error_message}: No frame found.\")          if current_frame.f_back is None:              raise RuntimeError(f\"{error_message}: taipy-gui module not found.\")          module_name = current_frame.f_back.f_globals[\"__name__\"]          self.__module = module = sys.modules[module_name]          with open(os.path.abspath(os.path.join(os.path.dirname(__file__), \"..\", \"viselements.json\"))) as viselements:              data = json.load(viselements)              if \"blocks\" not in data or \"controls\" not in data:                  raise RuntimeError(f\"{error_message}: Invalid viselements.json file.\")              for blockElement in data[\"blocks\"]:                  default_property = _ElementApiGenerator.find_default_property(blockElement[1][\"properties\"])                  setattr(                      module,                      blockElement[0],                      _ElementApiGenerator.create_block_api(blockElement[0], blockElement[0], default_property),                  )              for controlElement in data[\"controls\"]:                  default_property = _ElementApiGenerator.find_default_property(controlElement[1][\"properties\"])                  setattr(                      module,                      controlElement[0],                      _ElementApiGenerator.create_control_api(controlElement[0], controlElement[0], default_property),                  )        def add_library(self, library: \"ElementLibrary\"):          library_name = library.get_name()          if self.__module is None:              _TaipyLogger._get_logger().info(                  f\"Python API for extension library '{library_name}' is not available. To fix this, import 'taipy.gui.builder' before importing the extension library.\"              )              return          library_module = getattr(self.__module, library_name, None)          if library_module is None:              library_module = types.ModuleType(library_name)              setattr(self.__module, library_name, library_module)          for element_name, element in library.get_elements().items():              setattr(                  library_module,                  element_name,                  _ElementApiGenerator().create_control_api(                      element_name, f\"{library_name}.{element_name}\", element.default_attribute                  ),              )        @staticmethod      def create_block_api(          classname: str,          element_name: str,          default_property: str,      ):          return _ElementApiGenerator.create_element_api(classname, element_name, default_property, _Block)        @staticmethod      def create_control_api(          classname: str,          element_name: str,          default_property: str,      ):          return _ElementApiGenerator.create_element_api(classname, element_name, default_property, _Control)        @staticmethod      def create_element_api(          classname: str,          element_name: str,          default_property: str,          ElementBaseClass: t.Union[t.Type[_Block], t.Type[_Control]],      ):          return type(              classname,              (ElementBaseClass,),              {                  \"__init__\": lambda self, *args, **kwargs: ElementBaseClass.__init__(self, *args, **kwargs),                  \"_ELEMENT_NAME\": element_name,                  \"_DEFAULT_PROPERTY\": default_property,              },          ) "}
{"text": "import typing as t  from abc import ABC, abstractmethod  from os import path    from ..page import Page  from ..utils import _is_in_notebook, _varname_from_content  from ._html import _TaipyHTMLParser    if t.TYPE_CHECKING:      from ..builder._element import _Element      from ..gui import Gui      class _Renderer(Page, ABC):      def __init__(self, **kwargs) -> None:          \"\"\"NOT DOCUMENTED          Initialize a new _Renderer with the indicated content.            Arguments:              content (str): The text content or the path to the file holding the text to be transformed.            If *content* is a path to a readable file, the file is read entirely as the text template.          \"\"\"          from ..builder._element import _Element            super().__init__(**kwargs)          content: t.Optional[t.Union[str, _Element]] = kwargs.get(\"content\", None)          if content is None:              raise ValueError(\"'content' argument is missing for class '_Renderer'\")          self._content = \"\"          self._base_element: t.Optional[_Element] = None          self._filepath = \"\"          if isinstance(content, str):              self.__process_content(content)          elif isinstance(content, _Element):              self._base_element = content          else:              raise ValueError(                  f\"'content' argument has incorrect type '{type(content).__name__}'. This must be a string or an Builder element.\"              )        def __process_content(self, content: str) -> None:          if path.exists(content) and path.isfile(content):              return self.__parse_file_content(content)          if self._frame is not None:              frame_dir_path = path.dirname(path.abspath(self._frame.f_code.co_filename))              content_path = path.join(frame_dir_path, content)              if path.exists(content_path) and path.isfile(content_path):                  return self.__parse_file_content(content_path)          self._content = content        def __parse_file_content(self, content):          with open(t.cast(str, content), \"r\") as f:              self._content = f.read()              # Save file path for error handling              self._filepath = content        def set_content(self, content: str) -> None:          \"\"\"Set a new page content.            Reads the new page content and reinitializes the `Page^` instance to reflect the change.            !!! important              This function can only be used in an IPython notebook context.            Arguments:              content (str): The text content or the path to the file holding the text to be transformed.                  If *content* is a path to a readable file, the file is read entirely as the text                  template.            Exceptions:              RuntimeError: If this method is called outside an IPython notebook context.          \"\"\"          if not _is_in_notebook():              raise RuntimeError(\"'set_content()' must be used in an IPython notebook context\")          self.__process_content(content)        def _get_content_detail(self, gui: \"Gui\") -> str:          if self._filepath:              return f\"in file '{self._filepath}'\"          if varname := _varname_from_content(gui, self._content):              return f\"in variable '{varname}'\"          return \"\"        @abstractmethod      def render(self, gui: \"Gui\") -> str:          pass      class _EmptyPage(_Renderer):      def __init__(self) -> None:          super().__init__(content=\"<PageContent />\")        def render(self, gui: \"Gui\") -> str:          return self._content      class Markdown(_Renderer):      \"\"\"Page generator for *Markdown* text.        Taipy can use Markdown text to create pages that are the base of      user interfaces.        You can find details on the Taipy Markdown-specific syntax and how to add      Taipy Visual Elements in the [section on HTML](../gui/pages/index.md#using-markdown)      of the User Manual.      \"\"\"        def __init__(self, content: str, **kwargs) -> None:          \"\"\"Initialize a new `Markdown` page.            Arguments:              content (str): The text content or the path to the file holding the Markdown text                  to be transformed.<br/>                  If _content_ is a path to a readable file, the file is read as the Markdown                  template content.          \"\"\"          kwargs[\"content\"] = content          super().__init__(**kwargs)        # Generate JSX from Markdown      def render(self, gui: \"Gui\") -> str:          return gui._markdown.convert(self._content)      class Html(_Renderer):      \"\"\"Page generator for *HTML* text.        Taipy can use HTML code to create pages that are the base of      user interfaces.        You can find details on HTML-specific constructs and how to add      Taipy Visual Elements in the [section on HTML](../gui/pages/index.md#using-html)      of the User Manual.      \"\"\"        def __init__(self, content: str, **kwargs) -> None:          \"\"\"Initialize a new `Html` page.            Arguments:              content (str): The text content or the path to the file holding the HTML text to                  be transformed.<br/>                  If *content* is a path to a readable file, the file is read as the HTML                  template content.          \"\"\"          kwargs[\"content\"] = content          super().__init__(**kwargs)          self.head = None        # Modify path routes      def modify_taipy_base_url(self, base_url):          self._content = self._content.replace(\"{{taipy_base_url}}\", f\"{base_url}\")        # Generate JSX from HTML      def render(self, gui: \"Gui\") -> str:          parser = _TaipyHTMLParser(gui)          parser.feed_data(self._content)          self.head = parser.head          return parser.get_jsx() "}
{"text": "import typing as t    from .._warnings import _warn  from ..types import NumberTypes  from ..utils import _RE_PD_TYPE, _get_date_col_str_name, _MapDict      def _add_to_dict_and_get(dico: t.Dict[str, t.Any], key: str, value: t.Any) -> t.Any:      if key not in dico.keys():          dico[key] = value      return dico[key]      def _get_tuple_val(attr: tuple, index: int, default_val: t.Any) -> t.Any:      return attr[index] if len(attr) > index else default_val      def _get_columns_dict_from_list(      col_list: t.Union[t.List[str], t.Tuple[str]], col_types_keys: t.List[str], value: t.Any  ):      col_dict = {}      idx = 0      for col in col_list:          if col in col_types_keys:              col_dict[col] = {\"index\": idx}              idx += 1          elif col:              _warn(                  f'Error column \"{col}\" is not present in the Dataframe \"{value.head(0) if hasattr(value, \"head\") else value}\".'              )      return col_dict      def _get_columns_dict(  # noqa: C901      value: t.Any,      columns: t.Union[str, t.List[str], t.Tuple[str], t.Dict[str, t.Any], _MapDict],      col_types: t.Optional[t.Dict[str, str]] = None,      date_format: t.Optional[str] = None,      number_format: t.Optional[str] = None,      opt_columns: t.Optional[t.Set[str]] = None,  ):      if col_types is None:          return None      col_dict: t.Optional[dict] = None      if isinstance(columns, str):          col_dict = _get_columns_dict_from_list([s.strip() for s in columns.split(\";\")], col_types_keys, value)      elif isinstance(columns, (list, tuple)):          col_dict = _get_columns_dict_from_list(columns, col_types_keys, value)      elif isinstance(columns, _MapDict):          col_dict = columns._dict.copy()      elif isinstance(columns, dict):          col_dict = columns.copy()      if not isinstance(col_dict, dict):          _warn(\"Error: columns attributes should be a string, a list, a tuple or a dict.\")          col_dict = {}      nb_cols = len(col_dict)      if nb_cols == 0:          for col in col_types_keys:              col_dict[col] = {\"index\": nb_cols}              nb_cols += 1      else:          col_dict = {str(k): v for k, v in col_dict.items()}          if opt_columns:              for col in opt_columns:                  if col in col_types_keys and col not in col_dict:                      col_dict[col] = {\"index\": nb_cols}                      nb_cols += 1      idx = 0      for col, ctype in col_types.items():          col = str(col)          if col in col_dict:              re_type = _RE_PD_TYPE.match(ctype)              grps = re_type.groups() if re_type else ()              ctype = grps[0] if grps else ctype              col_dict[col][\"type\"] = ctype              col_dict[col][\"dfid\"] = col              if len(grps) > 4 and grps[4]:                  col_dict[col][\"tz\"] = grps[4]              idx = _add_to_dict_and_get(col_dict[col], \"index\", idx) + 1              if ctype == \"datetime\":                  if date_format:                      _add_to_dict_and_get(col_dict[col], \"format\", date_format)                  col_dict[_get_date_col_str_name(col_types.keys(), col)] = col_dict.pop(col)  # type: ignore              elif number_format and ctype in NumberTypes:                  _add_to_dict_and_get(col_dict[col], \"format\", number_format)      return col_dict "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from __future__ import annotations    from datetime import date, datetime, time  from json import JSONEncoder  from pathlib import Path    from flask.json.provider import DefaultJSONProvider    from .._warnings import _warn  from ..icon import Icon  from ..utils import _date_to_string, _MapDict, _TaipyBase      def _default(o):      if isinstance(o, Icon):          return o._to_dict()      if isinstance(o, _MapDict):          return o._dict      if isinstance(o, _TaipyBase):          return o.get()      if isinstance(o, (datetime, date, time)):          return _date_to_string(o)      if isinstance(o, Path):          return str(o)      try:          raise TypeError(f\"Object of type {o.__class__.__name__} is not JSON serializable\")      except Exception as e:          _warn(\"Exception in JSONEncoder\", e)          return None      class _TaipyJsonEncoder(JSONEncoder):      def default(self, o):          return _default(o)      class _TaipyJsonProvider(DefaultJSONProvider):      default = staticmethod(_default)  # type: ignore      sort_keys = False "}
{"text": "from markdown.treeprocessors import Treeprocessor    from ..builder import _Builder      class _Postprocessor(Treeprocessor):      @staticmethod      def extend(md, gui, priority):          instance = _Postprocessor(md)          md.treeprocessors.register(instance, \"taipy\", priority)          instance._gui = gui        def run(self, root):          MD_PARA_CLASSNAME = \"md-para\"          for p in root.iter():              if p.tag == \"p\":                  classes = p.get(\"class\")                  classes = f\"{MD_PARA_CLASSNAME} {classes}\" if classes else MD_PARA_CLASSNAME                  p.set(\"class\", classes)                  p.tag = \"div\"              if p != root:                  p.set(\"key\", _Builder._get_key(p.tag))          return root "}
{"text": "from markdown.inlinepatterns import InlineProcessor    from .factory import _MarkdownFactory      class _ControlPattern(InlineProcessor):      __PATTERN = _MarkdownFactory._TAIPY_START + r\"([a-zA-Z][\\.a-zA-Z_$0-9]*)(.*?)\" + _MarkdownFactory._TAIPY_END        @staticmethod      def extend(md, gui, priority):          instance = _ControlPattern(_ControlPattern.__PATTERN, md)          md.inlinePatterns.register(instance, \"taipy\", priority)          instance._gui = gui        def handleMatch(self, m, data):          return _MarkdownFactory.create_element(self._gui, m.group(1), m.group(2)), m.start(0), m.end(0) "}
{"text": "import re    from markdown.blockprocessors import BlockProcessor    from .factory import _MarkdownFactory      class _StartBlockProcessor(BlockProcessor):      __RE_FENCE_START = re.compile(          _MarkdownFactory._TAIPY_START + r\"([a-zA-Z][\\.a-zA-Z_$0-9]*)\\.start(.*?)\" + _MarkdownFactory._TAIPY_END      )  # start line      __RE_OTHER_FENCE = re.compile(          _MarkdownFactory._TAIPY_START + r\"([a-zA-Z][\\.a-zA-Z_$0-9]*)\\.(start|end)(.*?)\" + _MarkdownFactory._TAIPY_END      )  # start or end tag        @staticmethod      def extend(md, gui, priority):          instance = _StartBlockProcessor(md.parser)          md.parser.blockprocessors.register(instance, \"taipy\", priority)          instance._gui = gui        def test(self, parent, block):          return re.match(_StartBlockProcessor.__RE_FENCE_START, block)        def run(self, parent, blocks):          original_block = blocks[0]          original_match = re.search(_StartBlockProcessor.__RE_FENCE_START, original_block)          blocks[0] = re.sub(_StartBlockProcessor.__RE_FENCE_START, \"\", blocks[0], 1)          tag = original_match.group(1)          queue = [tag]          # Find block with ending fence          for block_num, block in enumerate(blocks):              matches = re.findall(_StartBlockProcessor.__RE_OTHER_FENCE, block)              for match in matches:                  if queue[-1] == match[0] and match[1] == \"end\":                      queue.pop()                  elif match[1] == \"start\":                      queue.append(match[0])              if not queue:                  # remove end fence                  blocks[block_num] = re.sub(                      _MarkdownFactory._TAIPY_START + tag + r\"\\.end(.*?)\" + _MarkdownFactory._TAIPY_END,                      \"\",                      block,                      1,                  )                  # render fenced area inside a new div                  e = _MarkdownFactory.create_element(self._gui, original_match.group(1), original_match.group(2))                  parent.append(e)                  # parse inside blocks                  self.parser.parseBlocks(e, blocks[: block_num + 1])                  # remove used blocks                  del blocks[: block_num + 1]                  return True  # or could have had no return statement          # No closing marker!  Restore and do nothing          blocks[0] = original_block          return False  # equivalent to our test() routine returning False "}
{"text": "from typing import Any    from markdown.extensions import Extension    from .blocproc import _StartBlockProcessor  from .control import _ControlPattern  from .postproc import _Postprocessor  from .preproc import _Preprocessor      class _TaipyMarkdownExtension(Extension):      config = {\"gui\": [\"\", \"Gui object for extension\"]}        def extendMarkdown(self, md):          from ...gui import Gui            gui = self.config[\"gui\"][0]          if not isinstance(gui, Gui):              raise RuntimeError(\"Gui instance is not bound to Markdown Extension\")          md.registerExtension(self)          _Preprocessor.extend(md, gui, 210)          _ControlPattern.extend(md, gui, 205)          _StartBlockProcessor.extend(md, gui, 175)          _Postprocessor.extend(md, gui, 200) "}
{"text": "import typing as t    from ..factory import _Factory      class _MarkdownFactory(_Factory):      # Taipy Markdown tags      _TAIPY_START = \"TaIpY:\"      _TAIPY_END = \":tAiPy\"        _TAIPY_BLOCK_TAGS = [\"layout\", \"part\", \"expandable\", \"dialog\", \"pane\"]        @staticmethod      def create_element(gui, control_type: str, all_properties: str) -> t.Union[t.Any, str]:          # Create properties dict from all_properties          property_pairs = _Factory._PROPERTY_RE.findall(all_properties)          properties = {property[0]: property[1] for property in property_pairs}          builder_md = _Factory.call_builder(gui, control_type, properties)          if builder_md is None:              return f\"<|INVALID SYNTAX - Control is '{control_type}'|>\"          return builder_md "}
{"text": "from .parser import _TaipyHTMLParser "}
{"text": "import typing as t    from ..factory import _Factory      class _HtmlFactory(_Factory):      @staticmethod      def create_element(gui, namespace: str, control_type: str, all_properties: t.Dict[str, str]) -> t.Tuple[str, str]:          builder_html = _Factory.call_builder(gui, f\"{namespace}.{control_type}\", all_properties, True)          if builder_html is None:              return f\"<div>INVALID SYNTAX - Control is '{namespace}:{control_type}'</div>\", \"div\"          return builder_html  # type: ignore "}
{"text": "import re  import typing as t  from html.parser import HTMLParser    from ..._warnings import _warn  from .factory import _HtmlFactory      class _TaipyHTMLParser(HTMLParser):      __TAIPY_NAMESPACE_RE = re.compile(r\"([a-zA-Z\\_]+):([a-zA-Z\\_]*)\")        def __init__(self, gui):          super().__init__()          self._gui = gui          self.body = \"\"          self.head = []          self.taipy_tag = None          self.tag_mapping = {}          self.is_body = True          self.head_tag = None          self._line_count = 0          self._tag_queue = []        # @override      def handle_starttag(self, tag, props) -> None:          self._tag_queue.append((tag, self._line_count))          if tag == \"html\":              return          if self.head_tag is not None:              self.head.append(self.head_tag)              self.head_tag = None          if self.taipy_tag is not None:              self.parse_taipy_tag()          if tag == \"head\":              self.is_body = False          elif tag == \"body\":              self.is_body = True          elif m := self.__TAIPY_NAMESPACE_RE.match(tag):              self.taipy_tag = _TaipyTag(m.group(1), m.group(2), props)          elif not self.is_body:              head_props = {prop[0]: prop[1] for prop in props}              self.head_tag = {\"tag\": tag, \"props\": head_props, \"content\": \"\"}          else:              self.append_data(str(self.get_starttag_text()))        # @override      def handle_data(self, data: str) -> None:          data = data.strip()          if data and self.taipy_tag is not None and self.taipy_tag.set_value(data):              self.parse_taipy_tag()          elif not self.is_body and self.head_tag is not None:              self.head_tag[\"content\"] = data          else:              self.append_data(data)        # @override      def handle_endtag(self, tag) -> None:          if not self._tag_queue:              _warn(f\"Closing '{tag}' at line {self._line_count} is missing an opening tag.\")          else:              opening_tag, opening_tag_line = self._tag_queue.pop()              if opening_tag != tag:                  _warn(                      f\"Opening tag '{opening_tag}' at line {opening_tag_line} has no matching closing tag '{tag}' at line {self._line_count}.\"                  )          if tag in [\"head\", \"body\", \"html\"]:              return          if self.taipy_tag is not None:              self.parse_taipy_tag()          if not self.is_body:              self.head.append(self.head_tag)              self.head_tag = None          elif tag in self.tag_mapping:              self.append_data(f\"</{self.tag_mapping[tag]}>\")          else:              self.append_data(f\"</{tag}>\")        def append_data(self, data: str) -> None:          if self.is_body:              self.body += data        def parse_taipy_tag(self) -> None:          tp_string, tp_element_name = self.taipy_tag.parse(self._gui)          self.append_data(tp_string)          self.tag_mapping[f\"{self.taipy_tag.namespace}:{self.taipy_tag.control_type}\"] = tp_element_name          self.taipy_tag = None        def get_jsx(self) -> str:          return self.body        def feed_data(self, data: str):          data_lines = data.split(\"\\n\")          for line, data_line in enumerate(data_lines):              self._line_count = line + 1              self.feed(data_line)          while self._tag_queue:              opening_tag, opening_tag_line = self._tag_queue.pop()              _warn(f\"Opening tag '{opening_tag}' at line {opening_tag_line} has no matching closing tag.\")      class _TaipyTag(object):      def __init__(self, namespace: str, tag_name: str, properties: t.List[t.Tuple[str, str]]) -> None:          self.namespace = namespace          self.control_type = tag_name          self.properties = {prop[0]: prop[1] for prop in properties}          self.has_set_value = False        def set_value(self, value: str) -> bool:          if self.has_set_value:              return False          property_name = _HtmlFactory.get_default_property_name(f\"{self.namespace}.{self.control_type}\")          # Set property only if it is not already defined          if property_name and property_name not in self.properties.keys():              self.properties[property_name] = value          self.has_set_value = True          return True        def parse(self, gui) -> t.Tuple[str, str]:          for k, v in self.properties.items():              self.properties[k] = v if v is not None else \"true\"          # allow usage of 'class' property in html taipy tag          if \"class\" in self.properties and \"class_name\" not in self.properties:              self.properties[\"class_name\"] = self.properties[\"class\"]          return _HtmlFactory.create_element(gui, self.namespace, self.control_type, self.properties) "}
{"text": "import pandas as pd  from taipy import Gui    # ---- READ EXCEL ----  df = pd.read_excel(      io=\"data/supermarkt_sales.xlsx\",      engine=\"openpyxl\",      sheet_name=\"Sales\",      skiprows=3,      usecols=\"B:R\",      nrows=1000,  )  # Add 'hour' column to dataframe  df[\"hour\"] = pd.to_datetime(df[\"Time\"], format=\"%H:%M:%S\").dt.hour      # initialization of variables  cities = list(df[\"City\"].unique())  types = list(df[\"Customer_type\"].unique())  genders = list(df[\"Gender\"].unique())  city = cities  customer_type = types  gender = genders    layout = {\"margin\": {\"l\": 220}}    # Markdown for the entire page  ## NOTE: {: .orange} references a color from main.css use to style my text  ## <text|  ## |text>  ## \"text\" here is just a name given to my part/my section  ## it has no meaning in the code  page = \"\"\"<|toggle|theme|>    <|layout|columns=20 80|gap=30px|  <sidebar|  ## Please **filter**{: .orange} here:    <|{city}|selector|lov={cities}|multiple|label=Select the City|dropdown|on_change=on_filter|width=100%|>    <|{customer_type}|selector|lov={types}|multiple|label=Select the Customer Type|dropdown|on_change=on_filter|width=100%|>    <|{gender}|selector|lov={genders}|multiple|label=Select the Gender|dropdown|on_change=on_filter|width=100%|>  |sidebar>    <main_page|  # \ud83d\udcca **Sales**{: .orange} Dashboard    <|layout|columns=1 1 1|  <total_sales|  ## **Total**{: .orange} sales:  ### US $ <|{int(df_selection[\"Total\"].sum())}|>  |total_sales>    <average_rating|  ## **Average**{: .orange} Rating:  ### <|{round(df_selection[\"Rating\"].mean(), 1)}|> <|{\"\u2b50\" * int(round(round(df_selection[\"Rating\"].mean(), 1), 0))}|>  |average_rating>    <average_sale|  ## Average Sales Per **Transaction**{: .orange}:  ### US $ <|{round(df_selection[\"Total\"].mean(), 2)}|>  |average_sale>  |>    <br/>    Display df_selection in an expandable  <|Sales Table|expandable|expanded=False|  <|{df_selection}|table|width=100%|page_size=5|rebuild|class_name=table|>  |>    <charts|  <|{sales_by_hour}|chart|x=Hour|y=Total|type=bar|title=Sales by Hour|color=#ff462b|>    <|{sales_by_product_line}|chart|x=Total|y=Product|type=bar|orientation=h|title=Sales by Product|layout={layout}|color=#ff462b|>  |charts>  |main_page>  |>    Code from [Coding is Fun](https://github.com/Sven-Bo)    Get the Taipy Code [here](https://github.com/Avaiga/demo-sales-dashboard) and the original code [here](https://github.com/Sven-Bo/streamlit-sales-dashboard)  \"\"\"      def filter(city, customer_type, gender):      df_selection = df[          df[\"City\"].isin(city)          & df[\"Customer_type\"].isin(customer_type)          & df[\"Gender\"].isin(gender)      ]        # SALES BY PRODUCT LINE [BAR CHART]      sales_by_product_line = (          df_selection[[\"Product line\", \"Total\"]]          .groupby(by=[\"Product line\"])          .sum()[[\"Total\"]]          .sort_values(by=\"Total\")      )      sales_by_product_line[\"Product\"] = sales_by_product_line.index        # SALES BY HOUR [BAR CHART]      sales_by_hour = (          df_selection[[\"hour\", \"Total\"]].groupby(by=[\"hour\"]).sum()[[\"Total\"]]      )      sales_by_hour[\"Hour\"] = sales_by_hour.index      return df_selection, sales_by_product_line, sales_by_hour      def on_filter(state):      state.df_selection, state.sales_by_product_line, state.sales_by_hour = filter(          state.city, state.customer_type, state.gender      )      if __name__ == \"__main__\":      # initialize dataframes      df_selection, sales_by_product_line, sales_by_hour = filter(          city, customer_type, gender      )        # run the app      Gui(page).run() "}
{"text": "from taipy.gui import Markdown  import numpy as np    import json    from data.data import data      type_selector = ['Absolute', 'Relative']  selected_type = type_selector[0]      def initialize_world(data):      data_world = data.groupby([\"Country/Region\",                                      'Date'])\\                              .sum()\\                              .reset_index()        with open(\"data/pop.json\",\"r\") as f:                              pop = json.load(f)            data_world['Population'] = data_world['Country/Region'].map(lambda x: pop.get(x, [None, 0])[1])        data_world = data_world.dropna()\\                              .reset_index()      data_world['Deaths/100k'] = data_world.loc[:,'Deaths']/data_world.loc[:,'Population']*100000            data_world_pie_absolute = data_world[['Country/Region', 'Deaths', 'Recovered', 'Confirmed']].groupby([\"Country/Region\"])\\                                          .max()\\                                          .sort_values(by='Deaths', ascending=False)[:20]\\                                          .reset_index()                                        data_world_pie_relative = data_world[['Country/Region', 'Deaths/100k']].groupby([\"Country/Region\"])\\                                          .max()\\                                          .sort_values(by='Deaths/100k', ascending=False)[:20]\\                                          .reset_index()            country_absolute = data_world_pie_absolute['Country/Region'].unique().tolist()      country_relative = data_world_pie_relative.loc[:,'Country/Region'].unique().tolist()                           data_world_evolution_absolute = data_world[data_world['Country/Region'].str.contains('|'.join(country_absolute),regex=True)]      data_world_evolution_absolute = data_world_evolution_absolute.pivot(index='Date', columns='Country/Region', values='Deaths')\\                                       .reset_index()            data_world_evolution_relative = data_world[data_world['Country/Region'].str.contains('|'.join(country_relative),regex=True)]      data_world_evolution_relative = data_world_evolution_relative.pivot(index='Date', columns='Country/Region', values='Deaths/100k')\\                                       .reset_index()      return data_world, data_world_pie_absolute, data_world_pie_relative, data_world_evolution_absolute, data_world_evolution_relative        data_world,\\  data_world_pie_absolute, data_world_pie_relative,\\  data_world_evolution_absolute, data_world_evolution_relative = initialize_world(data)          data_world_evolution_absolute_properties = {\"x\":\"Date\"}  cols = [col for col in data_world_evolution_absolute.columns if col != \"Date\"]  for i in range(len(cols)):      data_world_evolution_absolute_properties[f'y[{i}]'] = cols[i]      data_world_evolution_relative_properties = {\"x\":\"Date\"}  cols = [col for col in data_world_evolution_relative.columns if col != \"Date\"]  for i in range(len(cols)):      data_world_evolution_relative_properties[f'y[{i}]'] = cols[i]              world_md = Markdown(\"pages/world/world.md\")"}
{"text": "from taipy.gui import Markdown, notify  import datetime as dt      selected_data_node = None  selected_scenario = None  selected_date = None  default_result = {\"Date\": [dt.datetime(2020,10,1)], \"Deaths\": [0], \"ARIMA\": [0], \"Linear Regression\": [0]}      def on_submission_change(state, submitable, details):      if details['submission_status'] == 'COMPLETED':          state.refresh('selected_scenario')          notify(state, \"success\", \"Predictions ready!\")          print(\"Predictions ready!\")      elif details['submission_status'] == 'FAILED':          notify(state, \"error\", \"Submission failed!\")          print(\"Submission failed!\")      else:          notify(state, \"info\", \"In progress...\")          print(\"In progress...\")      def on_change_params(state):      if state.selected_date.year < 2020 or state.selected_date.year > 2021:          notify(state, \"error\", \"Invalid date! Must be between 2020 and 2021\")          state.selected_date = dt.datetime(2020,10,1)          return            state.selected_scenario.date.write(state.selected_date.replace(tzinfo=None))      state.selected_scenario.country.write(state.selected_country)      notify(state, \"success\", \"Scenario parameters changed!\")        state['Country'].on_change_country(state)      def on_change(state, var_name, var_value):      if var_name == 'selected_scenario' and var_value:          state.selected_date = state.selected_scenario.date.read()          state.selected_country = state.selected_scenario.country.read()      predictions_md = Markdown(\"pages/predictions/predictions.md\")"}
{"text": "from taipy.gui import Gui  from math import cos, exp    value = 10    page = \"\"\"  Markdown  # Taipy *Demo*    Value: <|{value}|text|>    <|{value}|slider|on_change=on_slider|>    <|{data}|chart|>  \"\"\"    def compute_data(decay:int)->list:      return [cos(i/6) * exp(-i*decay/600) for i in range(100)]    def on_slider(state):      state.data = compute_data(state.value)    data = compute_data(value)    Gui(page).run(use_reloader=True, port=5002)"}
{"text": "from taipy.gui import Gui  import taipy as tp    from pages.country.country import country_md  from pages.world.world import world_md  from pages.map.map import map_md  from pages.predictions.predictions import predictions_md, selected_scenario  from pages.root import root, selected_country, selector_country    from config.config import Config    pages = {      '/':root,      \"Country\":country_md,      \"World\":world_md,      \"Map\":map_md,      \"Predictions\":predictions_md  }      gui_multi_pages = Gui(pages=pages)    if __name__ == '__main__':      tp.Core().run()            gui_multi_pages.run(title=\"Covid Dashboard\") "}
{"text": "import yfinance as yf  from taipy.gui import Gui  from taipy.gui.data.decimator import MinMaxDecimator, RDP, LTTB      df_AAPL = yf.Ticker(\"AAPL\").history(interval=\"1d\", period=\"100Y\")  df_AAPL[\"DATE\"] = df_AAPL.index.astype(\"int64\").astype(float)    n_out = 500  decimator_instance = MinMaxDecimator(n_out=n_out)    decimate_data_count = len(df_AAPL)    page = \"\"\"  # Decimator    From a data length of <|{len(df_AAPL)}|> to <|{n_out}|>    ## Without decimator    <|{df_AAPL}|chart|x=DATE|y=Open|>    ## With decimator    <|{df_AAPL}|chart|x=DATE|y=Open|decimator=decimator_instance|>  \"\"\"    gui = Gui(page)  gui.run(port=5026) "}
{"text": "# Create an app to upload a csv and display it in a table  from taipy.gui import Gui  import pandas as pd    data = []  data_path = \"\"      def data_upload(state):      state.data = pd.read_csv(state.data_path)      page = \"\"\"  <|{data_path}|file_selector|on_action=data_upload|>  <|{data}|table|>  \"\"\"    Gui(page).run() "}
{"text": "import socket  import pickle  import math  from threading import Thread  from taipy.gui import Gui, State, invoke_callback, get_state_id  import numpy as np  import pandas as pd    init_lat = 49.247  init_long = 1.377    factory_lat = 49.246  factory_long = 1.369    diff_lat = abs(init_lat - factory_lat) * 15  diff_long = abs(init_long - factory_long) * 15    lats_unique = np.arange(init_lat - diff_lat, init_lat + diff_lat, 0.001)  longs_unique = np.arange(init_long - diff_long, init_long + diff_long, 0.001)    countdown = 20  periods = 0  line_data = pd.DataFrame({\"Time\": [], \"Max AQI\": []})    drone_data = pd.DataFrame(      {          \"Drone ID\": [43, 234, 32, 23, 5, 323, 12, 238, 21, 84],          \"Battery Level\": [              \"86%\",              \"56%\",              \"45%\",              \"12%\",              \"85%\",              \"67%\",              \"34%\",              \"78%\",              \"90%\",              \"100%\",          ],          \"AQI\": [40, 34, 24, 22, 33, 45, 23, 34, 23, 34],          \"Status\": [              \"Moving\",              \"Measuring\",              \"Measuring\",              \"Stopped\",              \"Measuring\",              \"Moving\",              \"Moving\",              \"Measuring\",              \"Measuring\",              \"Measuring\",          ],      }  )    HOST = \"127.0.0.1\"  PORT = 65432    layout_map = {      \"mapbox\": {          \"style\": \"open-street-map\",          \"center\": {\"lat\": init_lat, \"lon\": init_long},          \"zoom\": 13,      },      \"dragmode\": \"false\",      \"margin\": {\"l\": 0, \"r\": 0, \"b\": 0, \"t\": 0},  }    layout_line = {      \"title\": \"Max Measured AQI over Time\",      \"yaxis\": {\"range\": [0, 150]},  }    options = {      \"opacity\": 0.8,      \"colorscale\": \"Bluered\",      \"zmin\": 0,      \"zmax\": 140,      \"colorbar\": {\"title\": \"AQI\"},      \"hoverinfo\": \"none\",  }    config = {\"scrollZoom\": False, \"displayModeBar\": False}      def pollution(lat: float, long: float):      \"\"\"      Return pollution level in percentage      Pollution should be centered around the factory      Pollution should decrease with distance to factory      Pollution should have an added random component        Args:          - lat: latitude          - long: longitude        Returns:          - pollution level      \"\"\"      global countdown      return 80 * (0.5 + 0.5 * math.sin(countdown / 20)) * math.exp(          -(0.8 * (lat - factory_lat) ** 2 + 0.2 * (long - factory_long) ** 2) / 0.00005      ) + np.random.randint(0, 50)      lats = []  longs = []  pollutions = []  times = []  max_pollutions = []    for lat in lats_unique:      for long in longs_unique:          lats.append(lat)          longs.append(long)          pollutions.append(pollution(lat, long))    data_province_displayed = pd.DataFrame(      {          \"Latitude\": lats,          \"Longitude\": longs,          \"Pollution\": pollutions,      }  )    max_pollution = data_province_displayed[\"Pollution\"].max()      # Socket handler  def client_handler(gui: Gui, state_id_list: list):      s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)      s.bind((HOST, PORT))      s.listen()      conn, _ = s.accept()      while True:          if data := conn.recv(1024 * 1024):              pollutions = pickle.loads(data)              print(f\"Data received: {pollutions[:5]}\")              if hasattr(gui, \"_server\") and state_id_list:                  invoke_callback(                      gui,                      state_id_list[0],                      update_pollutions,                      [pollutions],                  )          else:              print(\"Connection closed\")              break      # Gui declaration  state_id_list = []    Gui.add_shared_variable(\"pollutions\")      def on_init(state: State):      state_id = get_state_id(state)      if (state_id := get_state_id(state)) is not None and state_id != \"\":          state_id_list.append(state_id)      update_pollutions(state, pollutions)      def update_pollutions(state: State, val):      state.pollutions = val      state.data_province_displayed = pd.DataFrame(          {              \"Latitude\": lats,              \"Longitude\": longs,              \"Pollution\": state.pollutions,          }      )      # Add an hour to the time      state.periods = state.periods + 1      state.max_pollutions = state.max_pollutions + [max(state.pollutions)]      state.times = pd.date_range(          \"2020-11-04\", periods=len(state.max_pollutions), freq=\"H\"      )      state.line_data = pd.DataFrame(          {              \"Time\": state.times,              \"Max AQI\": state.max_pollutions,          }      )      page = \"\"\"  <|{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|>  <|layout|columns=1 2 2|  <|part|class_name=card|  **Max Measured AQI:**<br/><br/><br/>  <|{int(data_province_displayed[\"Pollution\"].max())}|indicator|value={int(data_province_displayed[\"Pollution\"].max())}|min=140|max=0|>  <br/><br/>  **Average Measured AQI:**<br/><br/><br/>  <|{int(data_province_displayed[\"Pollution\"].mean())}|indicator|value={int(data_province_displayed[\"Pollution\"].mean())}|min=140|max=0|>  |>    <|part|class_name=card|  <|{drone_data}|table|show_all=True|>  |>    <|part|class_name=card|  <|{line_data[-30:]}|chart|type=lines|x=Time|y=Max AQI|layout={layout_line}|height=40vh|>  |>  |>  \"\"\"  gui = Gui(page=page)    t = Thread(      target=client_handler,      args=(          gui,          state_id_list,      ),  )  t.start()  gui.run(run_browser=False) "}
{"text": "\"\"\"  A page of the application.  Page content is imported from the Drift.md file.    Please refer to https://docs.taipy.io/en/latest/manuals/gui/pages for more details.  \"\"\"    import taipy as tp  from taipy.gui import Markdown  import pandas as pd  from taipy.gui import notify    from configuration.config import scenario_cfg    Drift = Markdown(\"pages/Drift/Drift.md\")      def merge_data(ref_data: pd.DataFrame, compare_data: pd.DataFrame):      \"\"\"      Merges the reference and comparison data into a single dataframe.      The Dataframe is prepared for plotting.        Args:          ref_data: The reference data.          compare_data: The comparison data.        Returns:          plot_data: The dataset for other columns.          sex_data: The dataset for sex distribution.      \"\"\"      bp_data = [          {\"Blood Pressure\": list(ref_data[\"blood_pressure\"])},          {\"Blood Pressure\": list(compare_data[\"blood_pressure\"])},      ]      # Count the Male and Female rows in ref and compare      male_ref = ref_data[ref_data[\"sex\"] == \"Male\"].shape[0]      male_compare = compare_data[compare_data[\"sex\"] == \"Male\"].shape[0]      female_ref = ref_data[ref_data[\"sex\"] == \"Female\"].shape[0]      female_compare = compare_data[compare_data[\"sex\"] == \"Female\"].shape[0]      sex_data = pd.DataFrame(          {              \"Dataset\": [\"Ref\", \"Compare\"],              \"Male\": [male_ref, male_compare],              \"Female\": [female_ref, female_compare],          }      )      return bp_data, sex_data      def on_ref_change(state):      state.ref_data = pd.read_csv(\"data/\" + state.ref_selected + \".csv\")      state.scenario.reference_data.write(state.ref_data)      state.bp_data, state.sex_data = merge_data(state.ref_data, state.compare_data)      def on_compare_change(state):      state.compare_data = pd.read_csv(\"data/\" + state.compare_selected + \".csv\")      state.scenario.compare_data.write(state.compare_data)      state.bp_data, state.sex_data = merge_data(state.ref_data, state.compare_data)      bp_options = [      # First data set displayed as green-ish, and 5 bins      {          \"marker\": {\"color\": \"#4A4\", \"opacity\": 0.8},          \"nbinsx\": 10,      },      # Second data set displayed as red-ish, and 25 bins      {          \"marker\": {\"color\": \"#A33\", \"opacity\": 0.8, \"text\": \"Compare Data\"},          \"nbinsx\": 10,      },  ]    bp_layout = {      # Overlay the two histograms      \"barmode\": \"overlay\",      \"title\": \"Blood Pressure Distribution (Green = Reference, Red = Compare)\",      \"showlegend\": False,  }      def on_submission_status_change(state, submittable, details):      submission_status = details.get(\"submission_status\")        if submission_status == \"COMPLETED\":          notify(state, \"success\", \"Drift Detection Completed\")          state.refresh(\"scenario\") "}
{"text": "from taipy.gui import Gui  import numpy as np    item1 = \"None\"  lov = [1, 2, 3]    page = \"\"\"  <|{item1}|selector|lov={lov}|>  \"\"\"    Gui(page).run() "}
{"text": "from taipy.gui import Gui  from math import cos, exp    state = {\"amp\": 1, \"data\":[]}    def update(state):    x = [i/10 for i in range(100)]    y = [math.sin(i)*state.amp for i in x]      state.data = [{\"data\": y}]    page = \"\"\"  Amplitude: <|{amp}|slider|>  <|Data|chart|data={data}|>   \"\"\"    Gui(page).run(state=state)"}
{"text": "  import numpy as np  from taipy.gui import Markdown    from data.data import data    marker_map = {\"color\":\"Deaths\", \"size\": \"Size\", \"showscale\":True, \"colorscale\":\"Viridis\"}  layout_map = {              \"dragmode\": \"zoom\",              \"mapbox\": { \"style\": \"open-street-map\", \"center\": { \"lat\": 38, \"lon\": -90 }, \"zoom\": 3}              }  options = {\"unselected\":{\"marker\":{\"opacity\":0.5}}}    def initialize_map(data):      data['Province/State'] = data['Province/State'].fillna(data[\"Country/Region\"])      data_province = data.groupby([\"Country/Region\",                                    'Province/State',                                    'Longitude',                                    'Latitude'])\\                           .max()                                   data_province_displayed = data_province[data_province['Deaths']>10].reset_index()        data_province_displayed['Size'] = np.sqrt(data_province_displayed.loc[:,'Deaths']/data_province_displayed.loc[:,'Deaths'].max())*80 + 3      data_province_displayed['Text'] = data_province_displayed.loc[:,'Deaths'].astype(str) + ' deaths </br> ' + data_province_displayed.loc[:,'Province/State']      return data_province_displayed      data_province_displayed = initialize_map(data)    map_md = Markdown(\"pages/map/map.md\") "}
{"text": "import requests  import json    # GitHub API setup  token = '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'  headers = {'Authorization': f'token {token}'}    # Function to recursively list files in a repository  def list_files_in_repo(repo_full_name, path=''):      url = f'https://api.github.com/repos/{repo_full_name}/contents/{path}'      response = requests.get(url, headers=headers)      files = response.json()        file_paths = []      for file in files:          if file['type'] == 'file' and (file['name'].endswith('.py') or file['name'].endswith('.md')):              file_paths.append(file['path'])          elif file['type'] == 'dir':              file_paths.extend(list_files_in_repo(repo_full_name, file['path']))            return file_paths    # Function to get the content of a file  def get_file_content(repo, file_path):      url = f'https://api.github.com/repos/{repo}/contents/{file_path}'      response = requests.get(url, headers=headers)      content = response.json().get('content', '')      return content    # Function to save content to JSONL  def save_to_jsonl(contents, filename='output.jsonl'):      with open(filename, 'w') as file:          for content in contents:              json_record = json.dumps({\"text\": content})              file.write(json_record + '\\n')  # Function to search repositories  def search_repos(query):      url = f'https://api.github.com/search/repositories?q={query}'      response = requests.get(url, headers=headers)      return response.json()['items']    # Main process  repositories = search_repos('Taipy')  file_contents = []    for repo in repositories:      file_paths = list_files_in_repo(repo['full_name'])      for file_path in file_paths:          content = get_file_content(repo['full_name'], file_path)          file_contents.append(content)    save_to_jsonl(file_contents) "}
{"text": "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": "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)      country_md = Markdown(\"pages/country/country.md\") "}
{"text": "import requests  import json  import logging    # Setup logging  logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')    # GitHub API setup  token = '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'  headers = {'Authorization': f'token {token}'}    # Function to search repositories  def search_repos(query):      url = f'https://api.github.com/search/repositories?q={query}'      response = requests.get(url, headers=headers)      return response.json()['items']    # Function to recursively list files in a repository  def list_files_in_repo(repo_full_name, path=''):      url = f'https://api.github.com/repos/{repo_full_name}/contents/{path}'      response = requests.get(url, headers=headers)      files = response.json()        file_paths = []      for file in files:          if file['type'] == 'file' and (file['name'].endswith('.py') or file['name'].endswith('.md')):              file_paths.append(file['path'])          elif file['type'] == 'dir':              file_paths.extend(list_files_in_repo(repo_full_name, file['path']))            return file_paths    # Function to get the content of a file  def get_file_content(repo, file_path):      url = f'https://api.github.com/repos/{repo}/contents/{file_path}'      response = requests.get(url, headers=headers)      content = response.json().get('content', '')      return content    # Function to save content to JSONL  def save_to_jsonl(contents, filename='output.jsonl'):      with open(filename, 'w') as file:          for content in contents:              json_record = json.dumps({\"text\": content})              file.write(json_record + '\\n')    # Main process  repositories = search_repos('Taipy')  logging.info(f'Found {len(repositories)} repositories with \"Taipy\"')    file_contents = []    for repo in repositories:      logging.info(f'Processing repository: {repo[\"full_name\"]}')      try:          file_paths = list_files_in_repo(repo['full_name'])          logging.info(f'Found {len(file_paths)} .py and .md files in {repo[\"full_name\"]}')            for file_path in file_paths:              content = get_file_content(repo['full_name'], file_path)              file_contents.append(content)              logging.info(f'Added content from {file_path}')      except Exception as e:          logging.error(f'Error processing repository {repo[\"full_name\"]}: {e}')    save_to_jsonl(file_contents)  logging.info('Finished processing all repositories') "}
{"text": "\"\"\"  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:<br />  Create a slider to select iterations  <|{iterations}|slider|min=10|max=50|continuous=False|on_change=generate|><br />  X Position:<br />  <|{dy_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />  Y Position:<br />    Slider dx_start  <|{dx_start}|slider|min=0|max=100|continuous=False|on_change=generate|><br />  |>  \"\"\"    Gui(page).run(title=\"Mandelbrot Generator\") "}
{"text": "from taipy.gui import Markdown     import numpy as np    from data.data import data    selector_country = list(np.sort(data['Country/Region'].astype(str).unique()))  selected_country = 'France'    root = Markdown(\"pages/root.md\")"}
{"text": "from taipy.gui import Gui  from math import cos, exp    value = 10    page = \"\"\"  Markdown  # Taipy *Demo*  Value: <|{value}|text|>    <|{value}|slider|>    <|{compute_data(value)}|chart|>  \"\"\"      def compute_data(decay: int) -> list:      return [cos(i / 6) * exp(-i * decay / 600) for i in range(100)]      Gui(page).run(use_reloader=True, port=5003) "}
{"text": "import pymongo  from dotenv import load_dotenv  import os  from taipy.gui import notify  import pandas as pd    load_dotenv()      client = pymongo.MongoClient(os.getenv(\"MONGO_URI\"))  db = client[\"GoShop\"]  collection_product = db[\"products\"]      def insert_one_collection(document):      return collection_product.insert_one(document)      def all_prodcuts():      cursor = collection_product.find()      list_cur = list(cursor)      df = pd.DataFrame(list_cur)      return df "}
{"text": "from taipy.gui import Gui, Markdown, navigate  from pages.addproduct import addproduct_md  from pages.home import home_md  from pages.developer import developer_md  favicone = \"https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcStQrffFMV3jCG2wB7o7Bs1VwUJ3Z0sWQhbzA&usqp=CAU\"    # root_md = \"<|menu|label=Menu|lov={[('home', Icon('https://static.vecteezy.com/system/resources/thumbnails/000/616/494/small/home-06.jpg','home')), ('addproduct', 'addproduct')]}|on_action=on_menu|>\"      def on_menu(state, action, info):      page = info[\"args\"][0]      navigate(state, to=page)      pages = {      \"/\": \"<center><|navbar|></center>\",      \"home\": home_md,      \"addproduct\": addproduct_md,      \"team\": developer_md,  }      Gui(pages=pages).run(title=\"Rapid~Receipt\", favicon=favicone,                       run_browser=False, use_reloader=True, port=5555) "}
{"text": "  from taipy.gui import Markdown, notify  from database import all_prodcuts  import pandas    products = all_prodcuts()      del products[\"_id\"]  products[\"isavailable\"].replace({True: \"Yes\", False: \"No\"})  yes = 0  no = 0  for i in products[\"isavailable\"]:      if i == True:          yes = yes+1      else:          no = no+1  data = {      \"Country\": [\"Sold\", \"Available\"],      \"Area\": [yes, no]  }    # for count vs products  # names_count = {}    # for name in products[\"name\"]:  #     if name in names_count:  #         names_count[name] += 1  #     else:  #         names_count = 1    # pairs = []  # for name, count in names_count.items():  #     for i in range(count):  #         pairs.append([name, count])  # data_p_vs_c = pandas.DataFrame(pairs, columns=[\"Products\", \"Quantity\"])    home_md = Markdown(\"\"\"  <|toggle|theme|>  <|container|  #  <center>**Rapid~Receipt**{: .color-primary} |Welcome Admin</center>      <|layout|columns=2 1|gap=30px|hover_text=true|  <|  ### List of products                       <|Table|expandable|  <|{products}|table|width=100%|>  |>   |>  <|  ### Available of Products  <|{data}|chart|type=pie|values=Area|labels=Country|>  |>  |>    ### Products sell       |>  \"\"\") "}
{"text": "  from taipy.gui import Markdown, notify, navigate    from database import insert_one_collection, all_prodcuts  image1 = \"https://www.identixweb.com/wp-content/uploads/2022/01/Add-Customization-for-Custom-Products.png\"  image2 = \"https://img.freepik.com/free-vector/online-wishes-list-concept-illustration_114360-3900.jpg\"  name = \"\"  price = \"\"  expiry = \"\"  pid = \"\"      def submit_action(state):      if state.pid == \"\" or state.price == \"\" or state.expiry == \"\" or state.pid == \"\":          notify(state, 'error', \"Product data is invalid\")          return      product = {          \"pid\": int(state.pid),          \"name\": state.name,          \"price\": state.price,          \"expiry\": state.expiry,          \"isavailable\": True,      }        insert_one_collection(product)      notify(state, 'info', \"Product inserted\")      navigate(state, to=\"/home\")      addproduct_md = Markdown(\"\"\"  <|toggle|theme|>  <|container|    ## Add **Product**{: .color-primary} \ud83d\udce6     <|   <|50 50|layout|class_name= card|  <|  <|layout|columns= 1 1|   <|  #### Product Id: <|{pid}|input|>  |>  <|  #### Product Name: <|{name}|input|>  |>  |>     <br/><br/>  <br/>       <|  <|layout|columns = 1 1  |  <|  #### Product Price: <|{price}|label=Price|input|>  |>  <|  #### Product Expiry: <|{expiry}|input|>  |>  |>  <br/>  <|submit|button|on_action=submit_action|>  |>  |>     <|{image2}|image|height=500px|width=500px|>  |>  |>     |>                                  \"\"\") "}
{"text": "from taipy.gui import Markdown  img1 = \"https://www.identixweb.com/wp-content/uploads/2022/01/Add-Customization-for-Custom-Products.png\"  developer_md = Markdown(\"\"\"  <|toggle|theme|>    ## Our Team **Mahi**{: .color-primary}   <|container  <|layout|columns= 1 1 1 |gap=30px|  <|  <|{img1}|image|width=100%|>    Suruchi  |>  <|   <|{img1}|image|width=100%|>   Shoaib  |>   <|{img1}|image|width=100%|>    Shivam  |>       |>                   \"\"\") "}
{"text": "from pages.dialogs.dialog_roc_md import *    from pages.compare_models_md import *  from pages.data_visualization_md import *  from pages.databases_md import *  from pages.model_manager_md import *    dialog_md = \"\"\"  <|dialog|open={dr_show_roc}|title=ROC Curve|partial={dialog_partial_roc}|on_action=delete_dialog_roc|labels=Close|width=1000px|>  \"\"\""}
{"text": "# \ud63c\ub3d9 \ud589\ub82c \ub300\ud654 \uc0c1\uc790  db_confusion_matrix_md = \"\"\"  <|part|render={db_table_selected=='Confusion Matrix'}|  <center>  <|{score_table}|table|height=200px|width=400px|show_all=True|>  </center>  |>  \"\"\"    # \ud559\uc2b5 \ub370\uc774\ud130 \uc138\ud2b8\uc5d0 \ub300\ud55c \ud14c\uc774\ube14  db_train_dataset_md = \"\"\"  <|part|render={db_table_selected=='Training Dataset'}|  <|{train_dataset}|table|width=1400px|height=560px|>  |>  \"\"\"    # \uc608\uce21 \ub370\uc774\ud130 \uc138\ud2b8\uc5d0 \ub300\ud55c \ud14c\uc774\ube14  db_forecast_dataset_md = \"\"\"  <|part|render={db_table_selected=='Forecast Dataset'}|  <center>  <|{values}|table|height=560px|width=800px|style={get_style}|>  </center>  |>  \"\"\"    # \ud14c\uc2a4\ud2b8 \ub370\uc774\ud130 \uc138\ud2b8\uc5d0 \ub300\ud55c \ud14c\uc774\ube14  db_test_dataset_md = \"\"\"  <|part|render={db_table_selected=='Test Dataset'}|  <|{test_dataset}|table|width=1400px|height=560px|>  |>  \"\"\"    # \ud45c\uc2dc\ud560 \ud14c\uc774\ube14\uc744 \uc120\ud0dd\ud558\ub294 \uc120\ud0dd\uae30  db_table_selector = ['Training Dataset', 'Test Dataset', 'Forecast Dataset', 'Confusion Matrix']  db_table_selected = db_table_selector[0]    # \uc804\uccb4 \ud398\uc774\uc9c0\ub97c \ub9cc\ub4e4\uae30 \uc704\ud55c \ubb38\uc790\uc5f4 \uc9d1\uacc4  db_databases_md = \"\"\"  # \ub370\uc774\ud130\ubca0\uc774\uc2a4    <|layout|columns=2 2 1|columns[mobile]=1|  <|  **Algorithm**: \\n \\n <|{mm_algorithm_selected}|selector|lov={mm_algorithm_selector}|dropdown=True|>  |>    <|  **Table**: \\n \\n <|{db_table_selected}|selector|lov={db_table_selector}|dropdown=True|>  |>    <br/>  <br/>  <|{PATH_TO_TABLE}|file_download|name=table.csv|label=Download table|>  |>  \"\"\" + db_test_dataset_md + db_confusion_matrix_md + db_train_dataset_md + db_forecast_dataset_md     "}
{"text": "from sklearn.metrics import f1_score    import pandas as pd  import numpy as np    cm_height_histo = \"100%\"  cm_dict_barmode = {\"barmode\": \"stack\",\"margin\":{\"t\":30}}  cm_options_md = \"height={cm_height_histo}|width={cm_height_histo}|layout={cm_dict_barmode}\"    cm_compare_models_md = \"\"\"  # \ubaa8\ub378 \ube44\uad50    <br/>  <br/>  <br/>    <|layout|columns= 1 1 1|columns[mobile]=1|  <|{accuracy_graph}|chart|type=bar|x=Pipeline|y[1]=Accuracy Model|y[2]=Accuracy Baseline|title=Accuracy|\"\"\" + cm_options_md + \"\"\"|>    <|{f1_score_graph}|chart|type=bar|x=Pipeline|y[1]=F1 Score Model|y[2]=F1 Score Baseline|title=F1 Score|\"\"\" + cm_options_md + \"\"\"|>    <|{score_auc_graph}|chart|type=bar|x=Pipeline|y[1]=AUC Score Model|y[2]=AUC Score Baseline|title=AUC Score|\"\"\" + cm_options_md + \"\"\"|>    |>  \"\"\"    def c_update_metrics(scenario, pipeline):      \"\"\"\uc774 \ud568\uc218\ub294 \ud30c\uc774\ud504\ub77c\uc778\uc744 \uc0ac\uc6a9\ud558\uc5ec \uc2dc\ub098\ub9ac\uc624\uc758 \uba54\ud2b8\ub9ad\uc744 \uc5c5\ub370\uc774\ud2b8\ud569\ub2c8\ub2e4.        Args:          scenario (scenario): \uc120\ud0dd\ud55c \uc2dc\ub098\ub9ac\uc624          pipeline (str): \uc120\ud0dd\ud55c \ud30c\uc774\ud504\ub77c\uc778\uc758 \uc774\ub984        Returns:          obj: \uc5ec\ub7ec \uac12, \uba54\ud2b8\ub9ad\uc744 \ub098\ud0c0\ub0b4\ub294 \ubaa9\ub85d      \"\"\"      metrics = scenario.pipelines[pipeline].metrics.read()        number_of_predictions = metrics['number_of_predictions']      number_of_good_predictions = metrics['number_of_good_predictions']      number_of_false_predictions = metrics['number_of_false_predictions']        accuracy = np.around(metrics['accuracy'], decimals=2)      f1_score = np.around(metrics['f1_score'], decimals=2)      score_auc = np.around(scenario.pipelines[pipeline].score_auc.read(),decimals=2)            dict_ftpn = metrics['dict_ftpn']            fp_ = dict_ftpn['fp']      tp_ = dict_ftpn['tp']      fn_ = dict_ftpn['fn']      tn_ = dict_ftpn['tn']            return number_of_predictions, accuracy, f1_score, score_auc, number_of_good_predictions, number_of_false_predictions, fp_, tp_, fn_, tn_      def compare_charts(accuracies, f1_scores, scores_auc, names):      \"\"\"\uc774 \ud568\uc218\ub294 \ubaa8\ub378 \ube44\uad50 \ud398\uc774\uc9c0\uc5d0\uc11c \uc0ac\uc6a9\ub418\ub294 pandas \ub370\uc774\ud130 \ud504\ub808\uc784(\ucc28\ud2b8)\uc744 \uc0dd\uc131\ud569\ub2c8\ub2e4.        Args:          accuracies (list): \uc815\ud655\ub3c4 \ubaa9\ub85d          f1_scores (list): f1 \uc810\uc218 \ubaa9\ub85d          scores_auc (list): auc \uc810\uc218 \ubaa9\ub85d          names (list): \uc2dc\ub098\ub9ac\uc624 \uc774\ub984 \ubaa9\ub85d        Returns:          pd.DataFrame: \uc138 \uac1c\uc758 \ub370\uc774\ud130\ud504\ub808\uc784\uc758 \uacb0\uacfc      \"\"\"      accuracy_graph = pd.DataFrame(create_metric_dict(accuracies, \"Accuracy\", names))      f1_score_graph = pd.DataFrame(create_metric_dict(f1_scores, \"F1 Score\", names))      score_auc_graph = pd.DataFrame(create_metric_dict(scores_auc, \"AUC Score\", names))        return accuracy_graph, f1_score_graph, score_auc_graph    def compare_models_baseline(scenario,pipelines):      \"\"\"\uc774 \ud568\uc218\ub294 \ud30c\uc774\ud504\ub77c\uc778 \ube44\uad50\ub97c \uc704\ud55c \uac1c\uccb4\ub97c \uc0dd\uc131\ud569\ub2c8\ub2e4.        Args:          scenario (scenario): \uc120\ud0dd\ud55c \uc2dc\ub098\ub9ac\uc624          pipelines (str): \uc120\ud0dd\ud55c \ud30c\uc774\ud504\ub77c\uc778\uc758 \uc774\ub984        Returns:          pd.DataFrame: \uc138 \uac1c\uc758 \ub370\uc774\ud130\ud504\ub808\uc784\uc758 \uacb0\uacfc      \"\"\"      accuracies = []      f1_scores = []      scores_auc = []      names = []      for pipeline in pipelines:          (_,accuracy,f1_score,score_auc,_,_,_,_,_,_) = c_update_metrics(scenario, pipeline)                    accuracies.append(accuracy)          f1_scores.append(f1_score)          scores_auc.append(score_auc)          names.append(pipeline[9:])                accuracy_graph,f1_score_graph, score_auc_graph = compare_charts(accuracies, f1_scores, scores_auc, names)      return accuracy_graph, f1_score_graph, score_auc_graph          def create_metric_dict(metric, metric_name, names):      \"\"\"\uc774 \ud568\uc218\ub294 Gui\uc5d0 \ud45c\uc2dc\ub41c \ub370\uc774\ud130 \ud504\ub808\uc784\uc5d0\uc11c \uc0ac\uc6a9\ub420 \uc5ec\ub7ec \ud30c\uc774\ud504\ub77c\uc778\uc5d0 \ub300\ud55c \uba54\ud2b8\ub9ad \uc0ac\uc804\uc744 \uc0dd\uc131\ud569\ub2c8\ub2e4.        Args:          metric (list): \uba54\ud2b8\ub9ad \uac12          metric_name (str): \uba54\ud2b8\ub9ad\uc758 \uc774\ub984          names (list): \uc2dc\ub098\ub9ac\uc624 \uc774\ub984 \ubaa9\ub85d        Returns:          dict: pandas \ub370\uc774\ud130\ud504\ub798\uc784\uc5d0 \uc0ac\uc6a9\ub418\ub294 \uc0ac\uc804      \"\"\"      metric_dict = {}      initial_list = [0]*len(names)            metric_dict[\"Pipeline\"] = names      for i in range(len(names)):          current_list = initial_list.copy()                    current_list[i] = metric[i]          metric_dict[metric_name +\" \"+ names[i].capitalize()] = current_list                return metric_dict     "}
{"text": "# Roc \ub2e4\uc774\uc5bc\ub85c\uadf8  dr_show_roc = False    def show_roc_fct(state):      state.dr_show_roc = True    def delete_dialog_roc(state):      state.dr_show_roc = False    dialog_roc = \"\"\"  <center>  <|{roc_dataset}|chart|x=False positive rate|y[1]=True positive rate|label[1]=True positive rate|height=500px|width=900px|type=scatter|>  </center>  \"\"\" "}
{"text": "from taipy.gui import Gui  from page.page import *      if __name__ == \"__main__\":      Gui(page).run(          use_reloader=True,          title=\"Wine \ud83c\udf77 production by Region and Year\",          dark_mode=False,      ) "}
{"text": "from taipy.core.config import Config  from config.config import df_wine_production      page = \"\"\"  # Wine production by Region and Year      ## Data for all the regions:  <|{df_wine_production}|table|height=400px|width=95%|>    \"\"\" "}
{"text": "import pandas as pd      def add_wine_colors(df_wine):      \"\"\"Adds 2 columns with      Args:          df_wine (DataFrame): Data from the csv file (input for the whole app)        Returns:          df_wine_with_colors: DataFrame with all the input columns plus 2 nexw ones, 'red_and_rose' and 'white',      and drops 2 columns that are not needed      \"\"\"      print(\"add wine color columns\")      df_wine_with_colors = df_wine.reset_index(drop=True)        df_wine_with_colors[\"red_and_rose\"] = 0      df_wine_with_colors[\"white\"] = 0        # General case:      df_wine_with_colors.loc[          df_wine_with_colors[\"wine_type\"].str.contains(\"ROUGE\"), \"red_and_rose\"      ] = 1      df_wine_with_colors.loc[          df_wine_with_colors[\"wine_type\"].str.contains(\"BLANC\"), \"white\"      ] = 1        # For some reason, there is some lines where the information about wine color is in the name:      df_wine_with_colors.loc[          df_wine_with_colors[\"AOC\"].str.contains(\"Rouge\")          & df_wine_with_colors[\"wine_type\"].str.contains(\"NORD - EST\"),          \"red_and_rose\",      ] = 1      df_wine_with_colors.loc[          df_wine_with_colors[\"AOC\"].str.contains(\"Blanc\")          & df_wine_with_colors[\"wine_type\"].str.contains(\"NORD - EST\"),          \"white\",      ] = 1        # Droip unnecessary columns      df_wine_with_colors = df_wine_with_colors.drop(columns=[\"data_type\", \"wine_type\"])        return df_wine_with_colors "}
{"text": "import taipy as tp  from taipy.core.config import Config    # Loading of the TOML  Config.load(\"config/taipy-config.toml\")    # Get the scenario configuration  scenario_cfg = Config.scenarios[\"SCENARIO_WINE\"]    tp.Core().run()    scenario_wine = tp.create_scenario(scenario_cfg)  scenario_wine.submit()      df_wine_production = scenario_wine.WINE_PRODUCTION_WITH_COLORS.read() "}
{"text": "from taipy.gui import Gui  from tensorflow.keras import models  from PIL import Image # to change img path to actual image  import numpy as np    class_names = {      0:'airplane',      1:'automobile',      2:'bird',      3:'cat',      4:'deer',      5:'dog',      6:'frog',      7:'horse',      8:'ship',      9:'truck',  }    model = models.load_model(\"baseline_mariya.keras\")    def image_predict(model, path_to_img):      img = Image.open(path_to_img)      img = img.convert(\"RGB\")      img = img.resize((32,32))      data = np.asarray(img)      data = data/255      probs = model.predict(np.array([data])[:1])      top_prob = probs.max()      top_pred = class_names[np.argmax(probs)]        return top_prob,top_pred      # index = \"<h1>Kaise Ho!!</h1>\"  # index = \"# Kaise Ho!!\"    img_path = \"img.png\"  content = \"\"  prob = 0  pred = \"\"    index = \"\"\"   <|text-center|  <|{\"logo.png\"}|image|width=12vw|>    <|{content}|file_selector|extensions=.png,.jpeg|>  Select an image from your file system      <|{pred}|>    <|{img_path}|image|>    <|{prob}|indicator|value={prob}|min=0|max=100|width=25vw|>  >  \"\"\"    def on_change(state, var_name,var_value):      if var_name == \"content\":          top_prob,top_pred = image_predict(model,var_value)          state.prob = round(top_prob*100)          state.pred = \"This is a \" + top_pred          state.img_path = var_value      # print(var_name, var_value)      app = Gui(page=index)    if __name__ == \"__main__\":      app.run(use_reloader=True)  # means we dont need to type python classifier.py to run it again just refresh the page "}
{"text": "from langchain.text_splitter import RecursiveCharacterTextSplitter  from langchain.document_loaders import TextLoader    loader = TextLoader(\"data/data_2.0.txt\")  # Use this line if you only need data.txt    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1500, chunk_overlap=0)  data = loader.load()  texts = text_splitter.split_documents(data)    from langchain.vectorstores import Chroma, Pinecone  from langchain.embeddings.openai import OpenAIEmbeddings  from dotenv import load_dotenv  import os  import time    load_dotenv()      OPENAI_API_KEY = os.environ.get(\"OPENAI_API_KEY\")      embeddings = OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY)  print(len(texts))    for i in range(0, len(texts), 100):      try:          db2 = Chroma.from_documents(              texts[i : i + min(100, len(texts) - i)],              embeddings,              persist_directory=\"chroma_db\",          )      except ValueError:          pass      time.sleep(10)      from langchain.chains import RetrievalQAWithSourcesChain  from langchain import OpenAI  from langchain.vectorstores import Chroma  from langchain.embeddings.openai import OpenAIEmbeddings    import os    embeddings = OpenAIEmbeddings()    docsearch = Chroma(persist_directory=\"chroma_db\", embedding_function=embeddings)    chain = RetrievalQAWithSourcesChain.from_chain_type(      OpenAI(temperature=0),      chain_type=\"stuff\",      retriever=docsearch.as_retriever(),      reduce_k_below_max_tokens=True,  )    user_input = input(\"What's your question: \")    result = chain({\"question\": user_input}, return_only_outputs=True)      print(\"Answer: \" + result[\"answer\"].replace(\"\\n\", \" \"))  print(\"Source: \" + result[\"sources\"]) "}
{"text": "from langchain.embeddings.openai import OpenAIEmbeddings  from dotenv import load_dotenv  import os    load_dotenv()      OPENAI_API_KEY = os.environ.get(\"OPENAI_API_KEY\")      from langchain.chains import RetrievalQAWithSourcesChain  from langchain import OpenAI  from langchain.vectorstores import Chroma  from langchain.embeddings.openai import OpenAIEmbeddings  from langchain.embeddings.openai import OpenAIEmbeddings  from langchain.vectorstores import Chroma  from langchain.text_splitter import CharacterTextSplitter  from langchain.llms import OpenAI  from langchain.chains import ConversationalRetrievalChain  from langchain.memory import ConversationBufferMemory    memory = ConversationBufferMemory(memory_key=\"chat_history\", return_messages=True)      import os    embeddings = OpenAIEmbeddings()    docsearch = Chroma(persist_directory=\"chroma_db\", embedding_function=embeddings)    chain = RetrievalQAWithSourcesChain.from_chain_type(      OpenAI(temperature=0),      chain_type=\"stuff\",      retriever=docsearch.as_retriever(),      reduce_k_below_max_tokens=True,  )      qa = ConversationalRetrievalChain.from_llm(      OpenAI(temperature=0),      docsearch.as_retriever(),      memory=memory,  )      while True:      user_input = input(\"What's your question: \")      if len(user_input) == 0:          break      print(          docsearch.similarity_search_with_score(              query=user_input, distance_metric=\"cos\", k=6          )      )        result = qa({\"question\": user_input})        print(\"Answer: \" + result[\"answer\"]) "}
{"text": "import os  import sys    import openai  from langchain.chains import RetrievalQA  from langchain.chat_models import ChatOpenAI  from langchain.document_loaders import DirectoryLoader, TextLoader  from langchain.embeddings import OpenAIEmbeddings  from langchain.indexes import VectorstoreIndexCreator  from langchain.indexes.vectorstore import VectorStoreIndexWrapper  from langchain.llms import OpenAI  from langchain.vectorstores import Chroma    import constants    os.environ[\"OPENAI_API_KEY\"] = constants.APIKEY    # Enable to save to disk & reuse the model (for repeated queries on the same data)  PERSIST = False    query = input(\"What's your question?\")    if PERSIST and os.path.exists(\"persist\"):      print(\"Reusing index...\\n\")      vectorstore = Chroma(          persist_directory=\"persist\", embedding_function=OpenAIEmbeddings()      )      index = VectorStoreIndexWrapper(vectorstore=vectorstore)  else:      # loader = TextLoader(\"data/data.txt\") # Use this line if you only need data.txt      loader = DirectoryLoader(\"data/\")      if PERSIST:          index = VectorstoreIndexCreator(              vectorstore_kwargs={\"persist_directory\": \"persist\"}          ).from_loaders([loader])      else:          index = VectorstoreIndexCreator().from_loaders([loader])    chain = RetrievalQA.from_chain_type(      llm=ChatOpenAI(model=\"gpt-3.5-turbo\"),      retriever=index.vectorstore.as_retriever(search_kwargs={\"k\": 1}),  )  print(chain.run(query)) "}
{"text": "s = open(\"data/data.txt\", \"r\")    s = s.read().replace(\"\\n\", \"\")    with open(\"data/new_data.txt\", \"w\") as x:      x.write(s) "}
{"text": "import requests  from bs4 import BeautifulSoup  from urllib.parse import urlparse, urljoin      def scrape_domain_and_subdomains(base_url, file_path):      visited_urls = set()        def scrape(url):          response = requests.get(url)          if response.status_code == 200:              soup = BeautifulSoup(response.content, \"html.parser\")              div_elements = soup.select(\"div.md-content\")                text = \"\"              for div in div_elements:                  text += div.get_text()              append_to_text_file(text, file_path)                links = soup.find_all(\"a\")              for link in links:                  href = link.get(\"href\")                  if href:                      subdomain_url = urljoin(url, href)                      parsed_url = urlparse(subdomain_url)                      if (                          parsed_url.netloc.endswith(\"docs.taipy.io\")                          and subdomain_url not in visited_urls                      ):                          visited_urls.add(subdomain_url)                          scrape(subdomain_url)        scrape(f\"http://{base_url}\")      print(visited_urls)      def append_to_text_file(content, file_path):      with open(file_path, \"a\", encoding=\"utf-8\") as file:          file.write(content)          file.write(\"\\n\")      # Example usage:  base_url = \"docs.taipy.io/en/latest/\"  # Replace with the base domain to scrape (without the protocol)  file_path = \"data/data_2.0.txt\"  # Replace with the desired file path    scrape_domain_and_subdomains(base_url, file_path) "}
{"text": "# This is a sample Python script.    # Press Maj+F10 to execute it or replace it with your code.  # Press Double Shift to search everywhere for classes, files, tool windows, actions, and settings.      def print_hi(name):      # Use a breakpoint in the code line below to debug your script.      print(f'Hi, {name}')  # Press Ctrl+F8 to toggle the breakpoint.      # Press the green button in the gutter to run the script.  if __name__ == '__main__':      print_hi('PyCharm')    # See PyCharm help at https://www.jetbrains.com/help/pycharm/ "}
{"text": "import taipy as tp  from taipy.gui import Gui, notify  from taipy.config import Config    import numpy as np  import pandas as pd      BUSINESS_PATH = \"data/yelp_business.csv\"    # Load the business data using pandas  business_df = pd.read_csv(BUSINESS_PATH)    # Remove quotation marks from the name  business_df.name = business_df.name.str[1:-1]    # Taipy Core  Config.load(\"config/config.toml\")    Config.configure_data_node(id=\"review_data\", read_fct_params=(\"data/yelp_review.csv\",))    scenario_object = Config.scenarios[\"scenario\"]  business_name = business_df.name[0]  reviews = None      def on_selection(state):      \"\"\"      Re-runs the scenario when the user selects a business.        Args:          - state: state of the app      \"\"\"      notify(state, \"info\", \"Running query...\")      business_scenarios = [          s for s in tp.get_scenarios() if s.name == state.business_name      ]      if len(business_scenarios) > 0:          scenario = business_scenarios[0]      else:          scenario = tp.create_scenario(scenario_object, name=state.business_name)          scenario.business_name.write(state.business_name)      tp.submit(scenario)      state.reviews = scenario.parsed_reviews.read()      notify(state, \"success\", \"Query finished\")      page = \"\"\"    # Querying **Big Data**{: .color-primary} with Taipy and Dask    ## Select a **business**{: .color-primary}    <|{business_name}|selector|lov={list(business_df.name)}|dropdown|on_change=on_selection|>        ## Average **stars**{: .color-primary} for that business: <|{\"\u2b50\"*int(np.mean(reviews.stars))}|text|raw|>    <|{round(np.mean(reviews.stars),2)}|indicator|value={np.mean(reviews.stars)}|min=1|max=5|width=30%|>    ## **Reviews**{: .color-primary} for that business:    <|{reviews}|table|width=100%|>  \"\"\"      def on_init(state):      scenario = tp.create_scenario(scenario_object, name=state.business_name)      tp.submit(scenario)      state.reviews = scenario.parsed_reviews.read()      if __name__ == \"__main__\":      tp.Core().run()      Gui(page).run() "}
{"text": "import dask.dataframe as dd      def get_data(path_to_csv: str, optional: str = None):      \"\"\"      Loads a csv file into a dask dataframe.      Converts the date column to datetime.        Args:          - path_to_csv: path to the csv file          - optional: optional argument (currently necessary to fix Core bug with generic data nodes)        Returns:          - dataset: dask dataframe      \"\"\"      dataset = dd.read_csv(path_to_csv)      dataset[\"date\"] = dd.to_datetime(dataset[\"date\"])      return dataset      def write_function():      \"\"\"      Useless function to fix Core bug with generic data nodes.      \"\"\"      return None"}
{"text": "import pandas as pd  import dask.dataframe as dd      def get_id_from_name(name: str, business_dict: dict):      \"\"\"      Returns the business_id from the name of the business.        Args:          - name: name of the business          - business_dict: dict with the name as key and the business_id as value        Returns:          - business_id: id of the business      \"\"\"      business_id = business_dict[name]      return business_id      def parse_business_data(data: dd.DataFrame):      \"\"\"      Parses the reviews of a business.        Args:          - data: dask dataframe with the reviews of a business        Returns:          - data: dask dataframe with the parsed reviews      \"\"\"      # Sort data by useful      data = data.sort_values(by=\"useful\", ascending=False)      # Keep only the stars, date and text columns      data = data[[\"stars\", \"date\", \"text\"]]      return data      def get_business_data(business_id: str, data: dd.DataFrame):      \"\"\"      Returns a dask dataframe with the reviews of a business.        Args:          - business_id: id of the business          - data: dask dataframe with the reviews        Returns:          - df_business: dask dataframe with the reviews of the business      \"\"\"      df_business = data[(data.business_id == business_id)].compute()      return df_business      def create_business_dict(business_df: pd.DataFrame):      \"\"\"      Creates a dict with the name as key and the business_id as value.        Args:          - business_df: pandas dataframe with the business data        Returns:          - business_dict: dict with the name as key and the business_id as value      \"\"\"      # Remove quotation marks from the name      business_df.name = business_df.name.str[1:-1]      business_dict = dict(zip(business_df.name, business_df.business_id))      print(business_dict)      return business_dict "}
{"text": "import time  import pandas as pd  import dask.dataframe as dd    def task1(path_to_original_data: str):      print(\"__________________________________________________________\")      print(\"1. TASK 1: DATA PREPROCESSING AND CUSTOMER SCORING ...\")      start_time = time.perf_counter()  # Start the timer            # Step 1: Read data using Dask      df = dd.read_csv(path_to_original_data)            # Step 2: Simplify the customer scoring formula      df['CUSTOMER_SCORE'] = (          0.5 * df['TotalPurchaseAmount'] / 1000 +          0.3 * df['NumberOfPurchases'] / 10 +          0.2 * df['AverageReviewScore']      )            # Save all customers to a new CSV file      scored_df = df[[\"CUSTOMER_SCORE\", \"TotalPurchaseAmount\", \"NumberOfPurchases\", \"TotalPurchaseTime\"]]            pd_df = scored_df.compute()        end_time = time.perf_counter()  # Stop the timer      execution_time = (end_time - start_time) * 1000  # Calculate the time in milliseconds      print(f\"Time of Execution: {execution_time:.4f} ms\")            return pd_df    def task2(scored_df, payment_threshold, score_threshold):      print(\"__________________________________________________________\")      print(\"2. TASK 2: FEATURE ENGINEERING AND SEGMENTATION ...\")        payment_threshold, score_threshold = float(payment_threshold), float(score_threshold)      start_time = time.perf_counter()  # Start the timer            df = scored_df            # Feature: Indicator if customer's total purchase is above the payment threshold      df['HighSpender'] = (df['TotalPurchaseAmount'] > payment_threshold).astype(int)            # Feature: Average time between purchases      df['AverageTimeBetweenPurchases'] = df['TotalPurchaseTime'] / df['NumberOfPurchases']            # Additional computationally intensive features      df['Interaction1'] = df['TotalPurchaseAmount'] * df['NumberOfPurchases']      df['Interaction2'] = df['TotalPurchaseTime'] * df['CUSTOMER_SCORE']      df['PolynomialFeature'] = df['TotalPurchaseAmount'] ** 2            # Segment customers based on the score_threshold      df['ValueSegment'] = ['High Value' if score > score_threshold else 'Low Value' for score in df['CUSTOMER_SCORE']]            end_time = time.perf_counter()  # Stop the timer      execution_time = (end_time - start_time) * 1000  # Calculate the time in milliseconds      print(f\"Time of Execution: {execution_time:.4f} ms\")            return df    def task3(df: pd.DataFrame, metric):      print(\"__________________________________________________________\")      print(\"3. TASK 3: SEGMENT ANALYSIS ...\")      start_time = time.perf_counter()  # Start the timer            # Detailed analysis for each segment: mean/median of various metrics      segment_analysis = df.groupby('ValueSegment').agg({          'CUSTOMER_SCORE': metric,          'TotalPurchaseAmount': metric,          'NumberOfPurchases': metric,          'TotalPurchaseTime': metric,          'HighSpender': 'sum',  # Total number of high spenders in each segment          'AverageTimeBetweenPurchases': metric      }).reset_index()            end_time = time.perf_counter()  # Stop the timer      execution_time = (end_time - start_time) * 1000  # Calculate the time in milliseconds      print(f\"Time of Execution: {execution_time:.4f} ms\")            return segment_analysis    def task4(df: pd.DataFrame, segment_analysis: pd.DataFrame, summary_statistic_type: str):      print(\"__________________________________________________________\")      print(\"4. TASK 4: ADDITIONAL ANALYSIS BASED ON SEGMENT ANALYSIS ...\")      start_time = time.perf_counter()  # Start the timer        # Filter out the High Value customers      high_value_customers = df[df['ValueSegment'] == 'High Value']            # Use summary_statistic_type to calculate different types of summary statistics      if summary_statistic_type == 'mean':          average_purchase_high_value = high_value_customers['TotalPurchaseAmount'].mean()      elif summary_statistic_type == 'median':          average_purchase_high_value = high_value_customers['TotalPurchaseAmount'].median()      elif summary_statistic_type == 'max':          average_purchase_high_value = high_value_customers['TotalPurchaseAmount'].max()      elif summary_statistic_type == 'min':          average_purchase_high_value = high_value_customers['TotalPurchaseAmount'].min()            median_score_high_value = high_value_customers['CUSTOMER_SCORE'].median()            # Fetch the summary statistic for 'TotalPurchaseAmount' for High Value customers from segment_analysis      segment_statistic_high_value = segment_analysis.loc[segment_analysis['ValueSegment'] == 'High Value', 'TotalPurchaseAmount'].values[0]        # Create a DataFrame to hold the results      result_df = pd.DataFrame({          'SummaryStatisticType': [summary_statistic_type],          'AveragePurchaseHighValue': [average_purchase_high_value],          'MedianScoreHighValue': [median_score_high_value],          'SegmentAnalysisHighValue': [segment_statistic_high_value]      })        end_time = time.perf_counter()  # Stop the timer      execution_time = (end_time - start_time) * 1000  # Calculate the time in milliseconds      print(f\"Time of Execution: {execution_time:.4f} ms\")        return result_df          if __name__ == \"__main__\":        t1 = task1(\"data/SMALL_amazon_customers_data.csv\")        t2 = task2(t1, 1500, 1.5)        t3 = task3(t2, \"mean\")        t4 = task4(t2, t3, \"mean\")            print(t4)   "}
{"text": "from recsys.recsys import page_scenario_manager  from taipy.gui import Gui      gui = Gui(page_scenario_manager)  gui.run() "}
{"text": "import pandas as pd  import numpy as np    TEST_RATIO = 0.2  MOVIELENS_DATA_PATH = \"u.data\"  MOVIE_DATA_PATH = \"u.item\"      def convert_data_to_dataframe(data_path: str, movie_path: str):      data = pd.read_table(data_path)      data.columns = [\"u_id\", \"i_id\", \"rating\", \"timestamp\"]      data_sort = data.sort_values(by=[\"u_id\"])        movie_name = pd.read_table(          movie_path, sep='|', encoding=\"latin-1\", header=None)      movie_name.drop([2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,                      15, 16, 17, 18, 19, 20, 21, 22, 23], inplace=True, axis=1)      movie_name.rename(columns={0: \"movieId\", 1: \"title\"}, inplace=True)        return data_sort, movie_name      movies_list = []    print(\"\\nReading the ratings file...\")  ratings, movie_name = convert_data_to_dataframe(      MOVIELENS_DATA_PATH, MOVIE_DATA_PATH)    userIds = ratings.u_id.unique()    trainIds = []  testIds = []    print(\"Splitting the ratings data...\")  for u in userIds:      rating_of_u = ratings.loc[ratings.u_id == u]        trainIds_sample = rating_of_u.sample(          frac=(1-TEST_RATIO), random_state=7)      testIds_sample = rating_of_u.drop(trainIds_sample.index.tolist())        for _, rating in trainIds_sample.iterrows():          if rating.i_id not in movies_list:              # Append new movie's Id to the movie list              movies_list.append(rating.u_id)        trainIds_sample = trainIds_sample.index.values      trainIds_sample.sort()      trainIds = np.append(trainIds, trainIds_sample)        testIds_sample = testIds_sample.index.values      testIds_sample.sort()      testIds = np.append(testIds, testIds_sample)  print(\"Done.\")    print(\"Write ratings to new file...\")  train = ratings.loc[ratings.index.isin(trainIds)]  train.to_csv(\"rating_train.csv\", index=False)  test = ratings.loc[ratings.index.isin(testIds)]  test.to_csv(\"rating_test.csv\", index=False)  movie_name.to_csv(\"movie.csv\", index=False)  print(\"Done.\") "}
{"text": "import pandas as pd  from datetime import datetime    data = pd.read_csv(\"dataset/rating_train.csv\")    timestamp = data.timestamp.to_list()  date = []  for time in timestamp:      date.append(datetime.fromtimestamp(time))  data[\"timestamp\"] = date  data.to_csv(\"data.csv\", index=False) "}
{"text": "import pandas as pd  import numpy as np  from scipy import sparse      class DataLoader:      def __init__(self):          self.__train_data = None          self.__val_data = None          self.__test_data = None        def __create_id_mapping(self):          if self.__val_data:              unique_uIds = pd.concat(                  [self.__train_data.u_id, self.__test_data.u_id, self.__val_data.u_id]              ).unique()              unique_iIds = pd.concat(                  [self.__train_data.i_id, self.__test_data.i_id, self.__val_data.i_id]              ).unique()          else:              unique_uIds = pd.concat(                  [self.__train_data.u_id, self.__test_data.u_id]              ).unique()              unique_iIds = pd.concat(                  [self.__train_data.i_id, self.__test_data.i_id]              ).unique()            self.user_dict = {uId: idx for idx, uId in enumerate(unique_uIds)}          self.item_dict = {iId: idx for idx, iId in enumerate(unique_iIds)}        def __preprocess(self, data):          \"\"\"Map the id of all users and items according to user_dict and item_dict.          To create the user_dict, all user ID in the training set is first sorted, then the first ID is map to 0 and so on.          Do the same for item_dict.          This process is done via `self.__create_id_mapping()`.            Args:              data (Dataframe): The dataset that need to be preprocessed.            Returns:              ndarray: The array with all id mapped.          \"\"\"          # data['u_id'] = data['u_id'].replace(self.user_dict)          # data['i_id'] = data['i_id'].replace(self.item_dict)            data[\"u_id\"] = data[\"u_id\"].map(self.user_dict)          data[\"i_id\"] = data[\"i_id\"].map(self.item_dict)            # Tag unknown users/items with -1 (when val)          data.fillna(-1, inplace=True)            data[\"u_id\"] = data[\"u_id\"].astype(np.int32)          data[\"i_id\"] = data[\"i_id\"].astype(np.int32)            return data[[\"u_id\", \"i_id\", \"rating\"]].values        def load_csv2ndarray(          self,          train_data,          test_data,          val_path=\"rating_val.csv\",          use_val=False,          columns=[\"u_id\", \"i_id\", \"rating\", \"timestamp\"],      ):          \"\"\"          Load training set, validate set and test set via `.csv` file.          Each as `ndarray`.            Args:              train_path (string): path to the training set csv file inside self.__data_folder              test_path (string): path to the testing set csv file inside self.__data_folder              val_path (string): path to the validating set csv file inside self.__data_folder              use_val (boolean): Denote if loading validate data or not. Defaults to False.              columns (list): Columns name for DataFrame. Defaults to ['u_id', 'i_id', 'rating', 'timestamp'].            Returns:              train, val, test (np.array): Preprocessed data.          \"\"\"          self.__train_data = train_data          self.__test_data = test_data            if use_val:              self.__val_data = self.__read_csv(val_path, columns)            self.__create_id_mapping()            self.__train_data = self.__preprocess(self.__train_data)          self.__test_data = self.__preprocess(self.__test_data)            if use_val:              self.__val_data = self.__preprocess(self.__val_data)              return self.__train_data, self.__val_data, self.__test_data          else:              return self.__train_data, self.__test_data        def load_genome_fromcsv(          self,          genome_file=\"genome_scores.csv\",          columns=[\"i_id\", \"g_id\", \"score\"],          reset_index=False,      ):          \"\"\"          Load genome scores from file.          Args:              genome_file (string): File name that contain genome scores. Must be in csv format.              columns (list, optional): Columns name for DataFrame. Must be [\"i_id\", \"g_id\", \"score\"] or [\"i_id\", \"score\", \"g_id\"].              reset_index (boolean): Reset the genome_tag column or not. Defaults to False.            Returns:              scores (DataFrame)          \"\"\"          genome = pd.read_csv(              self.__genome_folder + \"/\" + genome_file, header=0, names=columns          )            if reset_index:              tag_map = {                  genome.g_id: newIdx                  for newIdx, genome in genome.loc[genome.i_id == 1].iterrows()              }              genome[\"g_id\"] = genome[\"g_id\"].map(tag_map)            genome[\"i_id\"] = genome[\"i_id\"].map(self.item_dict)          genome.fillna(0, inplace=True)            return sparse.csr_matrix(              (genome[\"score\"], (genome[\"i_id\"].astype(int), genome[\"g_id\"].astype(int)))          ).toarray() "}
{"text": "from taipy import Config, Scope  from functions.funtions import preprocess_data, fit, predict  from config.svd_config import (      n_epochs_cfg,      n_factors_cfg,      learning_rate_cfg,      qi_cfg,      bi_cfg,      bu_cfg,      pu_cfg,  )  from config.kNN_config import (      x_id_cfg,      n_k_neighboor_cfg,      n_min_k_cfg,      sim_measure_cfg,      list_ur_ir_cfg,      similarity_matrix_cfg,      users_id_cfg,      items_id_cfg,  )  TRAIN_DATA_PATH = \"dataset/rating_train.csv\"  TEST_DATA_PATH = \"dataset/rating_test.csv\"  MOVIE_DATA_PATH = \"dataset/movie.csv\"    train_dataset_cfg = Config.configure_data_node(      id=\"train_dataset\",      storage_type=\"csv\",      path=TRAIN_DATA_PATH,      scope=Scope.GLOBAL,      cacheable=True,  )    test_dataset_cfg = Config.configure_data_node(      id=\"test_dataset\",      storage_type=\"csv\",      path=TEST_DATA_PATH,      scope=Scope.GLOBAL,      cacheable=True,  )  movie_name_cfg = Config.configure_data_node(      id=\"movie_name\",      storage_type=\"csv\",      path=MOVIE_DATA_PATH,      scope=Scope.GLOBAL,      cacheable=True,  )    trainset_cfg = Config.configure_data_node(      id=\"trainset\", scope=Scope.PIPELINE, cacheable=True)    testset_cfg = Config.configure_data_node(      id=\"testset\", scope=Scope.PIPELINE, cacheable=True)    true_testset_movies_id_cfg = Config.configure_data_node(      id=\"true_testset_movies_id\", scope=Scope.PIPELINE, cacheable=True  )  algorithm_cfg = Config.configure_in_memory_data_node(      id=\"algorithm\", default_data=\"kNN\")  global_mean_cfg = Config.configure_data_node(      id=\"global_mean\", cope=Scope.GLOBAL, cacheable=True  )  predictions_cfg = Config.configure_data_node(      id=\"predictions\", scope=Scope.PIPELINE)    # Config task  load_data_task_cfg = Config.configure_task(      id=\"load_data\",      function=preprocess_data,      input=[train_dataset_cfg, test_dataset_cfg, movie_name_cfg],      output=[trainset_cfg, testset_cfg, true_testset_movies_id_cfg],  )    train_data_task_cfg = Config.configure_task(      id=\"train_data\",      function=fit,      input=[          trainset_cfg, sim_measure_cfg,          n_factors_cfg, n_epochs_cfg, learning_rate_cfg,          algorithm_cfg,      ],      output=[          similarity_matrix_cfg, list_ur_ir_cfg, users_id_cfg, items_id_cfg, global_mean_cfg,          pu_cfg, qi_cfg, bu_cfg, bi_cfg,      ],  )    predict_task_cfg = Config.configure_task(      id=\"predict_task\",      function=predict,      input=[          testset_cfg,          x_id_cfg, list_ur_ir_cfg, similarity_matrix_cfg, n_k_neighboor_cfg, n_min_k_cfg, users_id_cfg, items_id_cfg,          global_mean_cfg, true_testset_movies_id_cfg,          bu_cfg, bi_cfg, pu_cfg, qi_cfg,          algorithm_cfg,      ],      output=predictions_cfg,  )      # Config pipeline  pipeline_cfg = Config.configure_pipeline(      id=\"pipeline\",      task_configs=[load_data_task_cfg, train_data_task_cfg, predict_task_cfg],  ) "}
{"text": "from taipy import Config, Scope    x_id_cfg = Config.configure_data_node(id=\"x_id\", default_data=1)    n_min_k_cfg = Config.configure_data_node(id=\"n_min_k\", default_data=10)    n_k_neighboor_cfg = Config.configure_data_node(      id=\"n_k_neighboor\", default_data=1)    sim_measure_cfg = Config.configure_in_memory_data_node(      id=\"sim_measure\", default_data=\"pcc\")    list_ur_ir_cfg = Config.configure_data_node(      id=\"list_ur_ir\", cope=Scope.GLOBAL, cacheable=True)    similarity_matrix_cfg = Config.configure_data_node(      id=\"similarity_matrix\", cope=Scope.GLOBAL, cacheable=True)    items_id_cfg = Config.configure_data_node(      id=\"x_list\", cope=Scope.GLOBAL, cacheable=True)    users_id_cfg = Config.configure_data_node(      id=\"y_list\", cope=Scope.GLOBAL, cacheable=True) "}
{"text": "from taipy import Config, Scope  n_factors_cfg = Config.configure_data_node(id=\"n_factors\", default_data=30)    n_epochs_cfg = Config.configure_data_node(id=\"n_epochs\", default_data=50)    learning_rate_cfg = Config.configure_data_node(id=\"learning_rate\", default_data=0.001)    qi_cfg = Config.configure_data_node(id=\"qi\", cope=Scope.GLOBAL, cacheable=True)    pu_cfg = Config.configure_data_node(id=\"pu\", cope=Scope.GLOBAL, cacheable=True)    bu_cfg = Config.configure_data_node(id=\"bu\", cope=Scope.GLOBAL, cacheable=True)    bi_cfg = Config.configure_data_node(id=\"bi\", cope=Scope.GLOBAL, cacheable=True)     "}
{"text": "import taipy as tp  from taipy.config import Config  from taipy.gui import notify, Markdown      import pandas as pd  import numpy as np    from helper.knn_helper import calculate_precision_recall  from config.config import pipeline_cfg    Config.configure_global_app(clean_entities_enabled=True)  tp.clean_all_entities()    scenario_cfg = Config.configure_scenario(      id=\"scenario\", pipeline_configs=pipeline_cfg)    dataset = pd.read_csv(\"dataset/data.csv\")  dataset[\"timestamp\"] = pd.to_datetime(dataset[\"timestamp\"])    sim_measure_selector = [\"pcc\", \"cosine\"]  selected_sim_measure = sim_measure_selector[0]    model_selector = [\"kNN\", \"MF\"]  selected_model = sim_measure_selector[0]  # set up parameter of kNN model  n_min_k, n_k_neighboor, x_id, top_k = 1, 10, 1, 1  # set up parameter of svd model  n_epochs, n_factors, learning_rate = 30, 40, 0.001    results, y_id, y_id_real, results_real, recall, precision = (      None, None, None, None, None, None,)    all_scenarios = tp.get_scenarios()  [tp.delete(scenario.id) for scenario in all_scenarios if scenario.name is None]    scenario_selector = [(scenario.id, scenario.name) for scenario in tp.get_scenarios()]      def create_scenario(state):      global selected_scenario        print(\"Creating scenario...\")        scenario = tp.create_scenario(scenario_cfg)        scenario.sim_measure.write(str(state.selected_sim_measure))      scenario.algorithm.write(str(state.selected_model))      scenario.n_min_k.write(int(state.n_min_k))      scenario.n_k_neighboor.write(int(state.n_k_neighboor))      scenario.x_id.write(int(state.x_id))      scenario.n_factors.write(int(state.n_factors))      scenario.n_epochs.write(int(state.n_epochs))      scenario.learning_rate.write(float(learning_rate))        selected_scenario = scenario.id      update_scenario_selector(state, scenario)      tp.submit(scenario)      def submit_scenario(state):      (          state.y_id,          state.y_id_real,          state.results_real,          state.recall,          state.precision,          state.results,      ) = (          None,          None,          [],          None,          None,          [],      )      print(\"Submitting scenario...\")      # Get the selected scenario: in this current step a single scenario is created then modified here.      scenario = tp.get(selected_scenario)        # Change the default parameters by writing in the datanodes      if scenario.sim_measure.read() != state.selected_sim_measure:          scenario.sim_measure.write(str(state.selected_sim_measure))      if scenario.n_min_k.read() != state.n_min_k:          scenario.n_min_k.write(int(state.n_min_k))      if scenario.n_k_neighboor.read() != state.n_k_neighboor:          scenario.n_k_neighboor.write(int(state.n_k_neighboor))      if scenario.x_id.read() != state.x_id:          scenario.x_id.write(int(state.x_id))      if scenario.n_factors.read() != state.n_factors:          scenario.n_factors.write(int(state.n_factors))      if scenario.n_epochs.read() != state.n_epochs:          scenario.n_epochs.write(int(state.n_epochs))      if scenario.learning_rate.read() != state.learning_rate:          scenario.learning_rate.write(float(learning_rate))      if scenario.algorithm.read() != state.selected_model:          scenario.algorithm.write(str(state.selected_model))        # Execute the pipelines/code      tp.submit(scenario)      def update_scenario_selector(state, scenario):      print(\"Updating scenario selector...\")      # Update the scenario selector      state.scenario_selector += [(scenario.id, scenario.name)]      def take_all_movies_rated_by_x_id(test_set, x_id):        test_items = []      test_set = test_set.copy()      for index in range(test_set.shape[0]):          if test_set[index][0] == x_id:              test_items.append(test_set[index])      test_items = np.array(test_items)      return test_items      def predicts(state):      id, predict, id_real, predict_real, user_ratings = (          [], [], [], [], [],)      scenario = tp.get(selected_scenario)      movie_name = (scenario.movie_name.read()).title.to_numpy()        print(\"'Predict' button clicked\")      result = scenario.predictions.read()      result = result[result[:, 4].argsort()[::-1]]        if state.top_k > result.shape[0]:          notify(              state,              notification_type=\"error\",              message=\"Out of range, top_k max = {}\".format(result.shape[0]),          )          state.top_k = result.shape[0]      top_k = state.top_k        test_set = scenario.testset.read()      true_testset_movies_id = scenario.true_testset_movies_id.read()        test_set[:, 1] = true_testset_movies_id.T      test_items = take_all_movies_rated_by_x_id(test_set, state.x_id)      test_items = test_items[test_items[:, 2].argsort()[::-1]]        for i in range(int(top_k)):          id.append(int(result[i][3]))          id_real.append(int(test_items[i][1]))        for i, j in zip(id, id_real):          predict.append(movie_name[(i - 1)])          predict_real.append(movie_name[(j - 1)])        state.y_id = np.array2string(          np.array(id), precision=2, separator=\", \", suppress_small=True)      state.y_id_real = np.array2string(          np.array(id_real), precision=2, separator=\", \", suppress_small=True)      state.results = predict      state.results_real = predict_real        for _, _, true_r, _, est in result:          user_ratings.append([est, true_r])      user_ratings = np.array(user_ratings)      state.precision, state.recall = calculate_precision_recall(          user_ratings, top_k, 3)      page_scenario_manager = Markdown(\"recsys/recsys.md\") "}
{"text": "import numpy as np  from numba import njit      def sgd(      X,      pu,      qi,      bu,      bi,      n_epochs,      global_mean,      n_factors,      lr_pu,      lr_qi,      lr_bu,      lr_bi,      reg_pu,      reg_qi,      reg_bu,      reg_bi,  ):      for epoch_ix in range(n_epochs):          pu, qi, bu, bi, train_loss = _run_svd_epoch(              X,              pu,              qi,              bu,              bi,              global_mean,              n_factors,              lr_pu,              lr_qi,              lr_bu,              lr_bi,              reg_pu,              reg_qi,              reg_bu,              reg_bi,          )        return pu, qi, bu, bi, train_loss      @njit  def _run_svd_epoch(      X,      pu,      qi,      bu,      bi,      global_mean,      n_factors,      lr_pu,      lr_qi,      lr_bu,      lr_bi,      reg_pu,      reg_qi,      reg_bu,      reg_bi,  ):      \"\"\"Runs an SVD epoch, updating model weights (pu, qi, bu, bi).        Args:          X (ndarray): the training set.          pu (ndarray): users latent factor matrix.          qi (ndarray): items latent factor matrix.          bu (ndarray): users biases vector.          bi (ndarray): items biases vector.          global_mean (float): ratings arithmetic mean.          n_factors (int): number of latent factors.          lr_pu (float, optional): Pu's specific learning rate.          lr_qi (float, optional): Qi's specific learning rate.          lr_bu (float, optional): bu's specific learning rate.          lr_bi (float, optional): bi's specific learning rate.          reg_pu (float, optional): Pu's specific regularization term.          reg_qi (float, optional): Qi's specific regularization term.          reg_bu (float, optional): bu's specific regularization term.          reg_bi (float, optional): bi's specific regularization term.        Returns:          pu (ndarray): the updated users latent factor matrix.          qi (ndarray): the updated items latent factor matrix.          bu (ndarray): the updated users biases vector.          bi (ndarray): the updated items biases vector.          train_loss (float): training loss.      \"\"\"      residuals = []      for i in range(X.shape[0]):          user, item, rating = int(X[i, 0]), int(X[i, 1]), X[i, 2]            # Predict current rating          pred = global_mean + bu[user] + bi[item]            for factor in range(n_factors):              pred += pu[user, factor] * qi[item, factor]            err = rating - pred          residuals.append(err)            # Update biases          bu[user] += lr_bu * (err - reg_bu * bu[user])          bi[item] += lr_bi * (err - reg_bi * bi[item])            # Update latent factors          for factor in range(n_factors):              puf = pu[user, factor]              qif = qi[item, factor]                pu[user, factor] += lr_pu * (err * qif - reg_pu * puf)              qi[item, factor] += lr_qi * (err * puf - reg_qi * qif)        residuals = np.array(residuals)      train_loss = np.square(residuals).mean()      return pu, qi, bu, bi, train_loss      @njit  def predict_svd_pair(u_id, i_id, global_mean, bu, bi, pu, qi):      \"\"\"Returns the model rating prediction for a given user/item pair.        Args:          u_id (int): a user id.          i_id (int): an item id.        Returns:          pred (float): the estimated rating for the given user/item pair.      \"\"\"      user_known, item_known = False, False      pred = global_mean        if u_id != -1:          user_known = True          pred += bu[u_id]        if i_id != -1:          item_known = True          pred += bi[i_id]        if user_known and item_known:          pred += np.dot(pu[u_id], qi[i_id])        return pred "}
{"text": "import pandas as pd  from prophet import Prophet  from taipy import Config    def clean_data(initial_dataset: pd.DataFrame):      print(\"Cleaning Data\")      initial_dataset = initial_dataset.rename(columns={\"Date\": \"ds\", \"Close\": \"y\"})      initial_dataset['ds'] = pd.to_datetime(initial_dataset['ds']).dt.tz_localize(None)      cleaned_dataset = initial_dataset.copy()      return cleaned_dataset    def retrained_model(cleaned_dataset: pd.DataFrame):      print(\"Model Retraining\")      model = Prophet()      model.fit(cleaned_dataset)      return model      def predict(model):      periods = 365      return model.predict(model.make_future_dataframe(periods=periods)[-periods:])[['ds', 'yhat']].rename(columns = {'ds':'Date', 'yhat':'Close_Prediction'})      ## Input Data Nodes  initial_dataset_cfg = Config.configure_data_node(id=\"initial_dataset\",                                                   storage_type=\"csv\",                                                   default_path='df.csv')    cleaned_dataset_cfg = Config.configure_data_node(id=\"cleaned_dataset\")                                                      clean_data_task_cfg = Config.configure_task(id=\"clean_data_task\",                                              function=clean_data,                                              input=initial_dataset_cfg,                                              output=cleaned_dataset_cfg,                                              skippable=True)      model_training_cfg = Config.configure_data_node(id=\"model_output\")                                                      predictions_cfg = Config.configure_data_node(id=\"predictions\")                                                      model_training_task_cfg = Config.configure_task(id=\"model_retraining_task\",                                                  function=retrained_model,                                                  input=cleaned_dataset_cfg,                                                  output=model_training_cfg,                                                  skippable=True)    predict_task_cfg = Config.configure_task(id=\"predict_task\",                                           function=predict,                                           input=model_training_cfg,                                           output=predictions_cfg,                                             skippable=True)    # Create our scenario configuration from our tasks  scenario_cfg = Config.configure_scenario_from_tasks(id=\"stock\",                                                      task_configs=[clean_data_task_cfg,                                                      model_training_task_cfg,                                                      predict_task_cfg])      \"\"\"  import taipy as tp  import yfinance as yf    # Run of the Taipy Core service  tp.Core().run()    def get_stock_data(ticker, start):      ticker_data = yf.download(ticker, start, dt.datetime.now()).reset_index()  # downloading the stock data from START to TODAY      ticker_data['Date'] = ticker_data['Date'].dt.tz_localize(None)      return ticker_data      tickers = {'MSFT':get_stock_data('MSFT', start_date),              'AAPL':get_stock_data('AAPL', start_date),              'GOOG':get_stock_data('GOOG', start_date)}    def create_and_submit_scenario(stock_name):      scenario_stock = tp.create_scenario(scenario_cfg, name=stock_name)      scenario_stock.initial_dataset.path = f\"{stock_name}.csv\"      scenario_stock.initial_dataset.write(tickers[stock_name])      tp.submit(scenario_stock)    for stock_name in tickers.keys():      create_and_submit_scenario(stock_name)    stocks = tp.get_scenarios()    for stock in stocks:      print(stock.name)      print(stock.predictions.read())  \"\"\""}
{"text": "from taipy.gui import Gui, notify  import pandas as pd  import yfinance as yf  from taipy.config import Config  import taipy as tp   import datetime as dt    Config.load('config_model_train.toml')  scenario_cfg = Config.scenarios['stock']    def get_stock_data(ticker, start):      ticker_data = yf.download(ticker, start, dt.datetime.now()).reset_index()  # downloading the stock data from START to TODAY      ticker_data['Date'] = ticker_data['Date'].dt.tz_localize(None)      return ticker_data    start_date = '2015-01-01'    property_chart = {\"type\":\"lines\",                    \"x\":\"Date\",                    \"y[1]\":\"Open\",                    \"y[2]\":\"Close\",                    \"y[3]\":\"High\",                    \"y[4]\":\"Low\",                    \"color[1]\":\"green\",                    \"color[2]\":\"grey\",                    \"color[3]\":\"red\",                    \"color[4]\":\"yellow\"                   }      df = pd.DataFrame([], columns = ['Date', 'High', 'Low', 'Open', 'Close'])  df_pred = pd.DataFrame([], columns = ['Date','Close_Prediction'])    stock_text = \"No Stock to Show\"  chart_text = 'No Chart to Show'  pred_text = 'No Prediction to Show'    stock = \"\"  stocks = []    page = \"\"\"  <|toggle|theme|>  # Stock Portfolio    ### Choose the stock to show    <|layout|columns=1 1|  <|{f'The stock is {stock.name}' if stock else 'No Stock to Show'}|>  <|{stock}|selector|lov={stocks}|dropdown|adapter={lambda s: s.name}|>  <|Reset|button|on_action=reset|>  <|Press for Stock|button|on_action=update_ticker_history|active={stock}|>  <|Update Model|button|on_action=update_model|active={stock}|>      <|{f'Monthly history of stock {stock.name}' if stock else 'No Chart to Show'}|>  <|{df}|chart|properties={property_chart}|>  |>    <|{f'1 Year Close Prediction of Stock {stock.name}' if stock else 'No Prediction to Show'}|>  <|{df_pred}|chart|x=Date|y=Close_Prediction|>  \"\"\"    def reset(state):      state.stock = \"\"      state.df = pd.DataFrame([], columns = ['Date', 'High', 'Low', 'Open', 'Close'])      state.df_pred = pd.DataFrame([], columns = ['Date','Close_Prediction'])      notify(state, 'success', 'Reset done!')        def update_ticker_history(state):      state.stock.initial_dataset.write(get_stock_data(state.stock.name, start_date))      on_change(state, \"stock\", state.stock)      notify(state, 'success', 'History up-to-date! You should retrain the model')    def on_change(state, var_name, var_value):      if var_name == \"stock\" and var_value:          state.df = state.stock.initial_dataset.read()          state.df_pred = state.stock.predictions.read()          def update_model(state):      print(\"Update Model Clicked\")      tp.submit(state.stock)      on_change(state, \"stock\", state.stock)      notify(state, 'success', 'Model trained and charts up-to-date!')      def on_init(state):      tickers = {'MSFT':get_stock_data('MSFT', start_date),                 'AAPL':get_stock_data('AAPL', start_date),                 'GOOG':get_stock_data('GOOG', start_date)}        def create_and_submit_scenario(stock_name):          scenario_stock = tp.create_scenario(scenario_cfg, name=stock_name)          scenario_stock.initial_dataset.path = f\"{stock_name}.csv\"          scenario_stock.initial_dataset.write(tickers[stock_name])          tp.submit(scenario_stock)        for stock_name in tickers.keys():          create_and_submit_scenario(stock_name)        state.stocks = tp.get_scenarios()      state.stock = state.stocks[0]    tp.Core().run()  Gui(page).run() "}
{"text": "from taipy import Gui  import pandas as pd    # Interactive GUI and state, we maintain states for each individual client  # hence we can have multiple clients with each client having its own state,  # change of the state of one client will not affect the other client's state.    # Each client has its own state and global values are made local to this states,  # example n_weeks, can be stored as state.n_weeks hence changing the state of one  # client does not affect the global n_week or the state of other clients.    # Each time the on_change() is called, three arguments are passed in:  # 1. state  # 2. var_name,  # 3. var_value  # where the state is unique to that client that made the call.    # Whenever a state of a client get changed, on_change() is called with three  # params, this function is a special function in Taipy.    n_weeks = 10      def read_data(dataset_path: str):      df = pd.read_csv(dataset_path)      df[\"Date\"] = pd.to_datetime(df[\"Date\"])      return df      dataset = read_data(\"./dataset/dataset.csv\")  dataset_week = dataset[dataset[\"Date\"].dt.isocalendar().week == n_weeks]      def on_change(state, var_name: str, var_value):      if var_name == \"n_weeks\":          state.dataset_week = dataset[dataset[\"Date\"].dt.isocalendar(          ).week == var_value]      page = \"\"\"  # Taipy Basics    *Week number*: *<|{n_weeks}|>*    <|{n_weeks}|slider|min=3|max=52|>    <|{dataset_week}|chart|type=bar|x=Date|y=Value|height=100%|width=100%|>  \"\"\"    Gui(page=page).run(dark_mode=False) "}
{"text": "from taipy import Gui  import pandas as pd    # visual elements: Taipy adds visual elements on top of markdown  # to give you the ability to add charts, tables... The format for  # it is as follows:    # <|{variable}|visual_element_name|param_1=param_1|param_2=param_2| ... |>.  # variable: python variable eg dataframe  # visual_element_name: Name of the visual element eg table  # para_1: parameters passed in    n_weeks = 10    def read_data(dataset_path: str):      df = pd.read_csv(dataset_path)      return df    dataset = read_data(\"./dataset/dataset.csv\")    page = \"\"\"  # Taipy Basics    *Week number*: *<|{n_weeks}|>*    <|{n_weeks}|slider|min=2|max=30|>    <|{dataset[9000:]}|chart|type=bar|x=Date|y=Value|height=100%|>    # Table Format  <|{dataset}|table|height=400px|width=95%|>  \"\"\"      Gui(page=page).run(dark_mode=False)      "}
{"text": "from taipy import Gui    # not no empty spaces at the beginning of the markdown  # markdown must start from the baseline    page = \"\"\"  ### Hello world  \"\"\"  # Gui(page=page).run(dark_mode=False)    # you can specify the port number in the run(port=xxxx)  # its by default 5000  Gui(page=\"Intro to Taipy\").run(dark_mode=True)   "}
{"text": "import taipy as tp  from taipy import Scope, Config  from taipy.core import Frequency    import json  from algos.algos import *    # \uc774 \ucf54\ub4dc\ub294 \uc2dc\ub098\ub9ac\uc624_cfg \ubc0f \ud30c\uc774\ud504\ub77c\uc778_csg\ub97c \uc0dd\uc131\ud558\ub294 \ucf54\ub4dc\uc785\ub2c8\ub2e4.   # \uc774 \ub450 \ubcc0\uc218\ub294 \uae30\ubcf8 \ucf54\ub4dc\uc5d0\uc11c \uc0c8 \uc2dc\ub098\ub9ac\uc624\ub97c \ub9cc\ub4dc\ub294 \ub370 \uc0ac\uc6a9\ub429\ub2c8\ub2e4.    # \uc774 \ucf54\ub4dc\ub294 \uc2e4\ud589 \uadf8\ub798\ud504\ub97c \uad6c\uc131\ud560 \uac83\uc785\ub2c8\ub2e4.    ###############################################################################  # \ub370\uc774\ud130\ub178\ub4dc  ###############################################################################    # \uccab \ubc88\uc9f8 \ub370\uc774\ud130 \ub178\ub4dc\ub97c \uc0dd\uc131\ud569\ub2c8\ub2e4. \uc18c\uc2a4\ub294 csv \ud30c\uc77c\uc785\ub2c8\ub2e4.  path_to_demand = 'data/time_series_demand.csv'  demand_cfg = Config.configure_data_node(id=\"demand\",                                  storage_type=\"csv\",                                   scope=Scope.SCENARIO,                                  path=path_to_demand,                                  has_header=True)      fixed_variables_default_json = open('data/fixed_variables_default.json')  fixed_variables_default = json.load(fixed_variables_default_json)    # fixed_variables_default\ub97c \uae30\ubcf8 \ub370\uc774\ud130\ub85c \ud558\ub294 \ub450 \ubc88\uc9f8 \ub370\uc774\ud130 \ub178\ub4dc \uc0dd\uc131   # \uc774\uac83\uc740 fixed_variable\uc5d0 \ub300\ud55c \ub2e4\ub978 \uac12\uc744 \uc81c\ucd9c\ud560 \ub54c \uc4f8 \uc774 \ub370\uc774\ud130 \ub178\ub4dc\uc785\ub2c8\ub2e4.  fixed_variables_cfg = Config.configure_data_node(id=\"fixed_variables\", default_data = fixed_variables_default, scope=Scope.PIPELINE)    # \ubaa8\ub378\uc744 \ucd94\uc801\ud558\ub294 \ub370\uc774\ud130 \ub178\ub4dc\ub294 \ub2e4\uc74c\uacfc \uac19\uc2b5\ub2c8\ub2e4. model_created \ub370\uc774\ud130 \ub178\ub4dc, model_solved \ub370\uc774\ud130 \ub178\ub4dc  model_created_cfg = Config.configure_data_node(id=\"model_created\", scope=Scope.PIPELINE)  model_solved_cfg = Config.configure_data_node(id=\"model_solved\", scope=Scope.PIPELINE)    # \uc774\uac83\uc740 \uba54\uc778 \ucf54\ub4dc\uc5d0\uc11c \uacb0\uacfc\ub97c \uc5bb\ub294 \ub370 \uc0ac\uc6a9\ud560 \ub370\uc774\ud130 \ub178\ub4dc\uc785\ub2c8\ub2e4.  results_cfg = Config.configure_data_node(id=\"results\", scope=Scope.PIPELINE)    ###############################################################################  # \uc791\uc5c5  ###############################################################################    # (demand_cfg,fixed_variables_cfg) -> |create_model| -> (model_created_cfg)  create_model_task = Config.configure_task(id=\"create_model\",                              input=[demand_cfg,fixed_variables_cfg],                              function=create_model,                              output=[model_created_cfg])    # (model_created_cfg) -> |solve_model| -> (model_solved_cfg)  solve_model_cfg = Config.configure_task(id=\"solve_model\",                                      input=[model_created_cfg],                                      function=solve_model,                                      output=[model_solved_cfg])    # (model_solved_cfg,fixed_variables_cfg,demand_cfg) -> |create_results| -> (results_cfg)  create_results_cfg = Config.configure_task(id=\"create_results\",                                         input=[model_solved_cfg,fixed_variables_cfg,demand_cfg],                                         function=create_results,                                         output=[results_cfg])      ###############################################################################  # \ud30c\uc774\ud504\ub77c\uc778 \ubc0f \uc2dc\ub098\ub9ac\uc624 \uad6c\uc131  ###############################################################################    # \ud30c\uc774\ud504\ub77c\uc778 : \uc791\uc5c5 \uc2e4\ud589. \uc77c\ub828\uc758 \uc791\uc5c5\uc744 \uc218\ud589\ud558\ub294 \uac83\uc744 \ub9d0\ud569\ub2c8\ub2e4.   pipeline_cfg = Config.configure_pipeline(id=\"pipeline\",task_configs=[create_model_task,solve_model_cfg,create_results_cfg])    # \uc2dc\ub098\ub9ac\uc624 : \ud30c\uc774\ud504\ub77c\uc778 \uc2e4\ud589. \uc77c\ub828\uc758 \ud30c\uc774\ud504\ub77c\uc778(\uc5ec\uae30\uc11c\ub294 \ud558\ub098\ub9cc)\uc758 \uc2e4\ud589\uc744 \ub098\ud0c0\ub0c5\ub2c8\ub2e4.  # \uc774 \ubcc0\uc218\ub97c \ud1b5\ud574 \uc0c8\ub85c\uc6b4 \uc2dc\ub098\ub9ac\uc624\ub97c \uc0dd\uc131\ud569\ub2c8\ub2e4.  scenario_cfg = Config.configure_scenario(id=\"scenario\",pipeline_configs=[pipeline_cfg], frequency=Frequency.MONTHLY)   "}
{"text": "import numpy as np  import pandas as pd    # \uc774 \ucf54\ub4dc\ub294 \uc218\uc694\uc5d0 \ub300\ud55c csv \ud30c\uc77c\uc744 \uc0dd\uc131\ud558\ub294 \ub370 \uc0ac\uc6a9\ub418\uba70 \ubb38\uc81c\uc758 \uc18c\uc2a4 \ub370\uc774\ud130\uc785\ub2c8\ub2e4.    def create_time_series(nb_months=12,mean_A=840,mean_B=760,std_A=96,std_B=72, amplitude_A=108,amplitude_B=144):      time_series_A = []      time_series_A.append(mean_A)            time_series_B = []      time_series_B.append(mean_B)            for i in range(1,nb_months):          time_series_A.append(np.random.normal(mean_A + amplitude_A*np.sin(2*np.pi*i/12),std_A))          time_series_B.append(np.random.normal(mean_B + amplitude_B*np.sin((2*np.pi*(i+6))/12),std_B))                time_series_A = pd.Series(time_series_A)      time_series_B = pd.Series(time_series_B)      month = [i%12 for i in range(nb_months)]      year = [i//12 + 2020 for i in range(nb_months)]      df_time_series = pd.DataFrame({\"Year\":year,\"Month\":month,\"Demand_A\":time_series_A,\"Demand_B\":time_series_B})      return df_time_series      def time_series_to_csv(nb_months=12,mean_A=840,mean_B=760,std_A=96,std_B=72, amplitude_A=108,amplitude_B=144):      time_serie_data = create_time_series(nb_months,mean_A,mean_B,std_A,std_B, amplitude_A,amplitude_B)      time_serie_data.to_csv('data/time_series_demand.csv') "}
{"text": "da_display_table_md = \"<center>\\n<|{ch_results.round()}|table|columns={list(chart.columns)}|width=fit-content|height={height_table}|></center>\\n\"  d_chart_csv_path = None    def da_create_display_table_md(str_to_select_chart):      return \"<center>\\n<|{\" + str_to_select_chart + \\          \"}|table|width=fit-content|height={height_table}|></center>\\n\"      da_databases_md = \"\"\"  # \ub370\uc774\ud130 \uc18c\uc2a4    <|layout|columns=3 2 1|columns[mobile]=1|  <layout_scenario|  <|layout|columns=1 1 3|columns[mobile]=1|  <year|  Year    <|{sm_selected_year}|selector|lov={sm_year_selector}|dropdown|width=100%|on_change=change_sm_month_selector|>  |year>    <month|  Month    <|{sm_selected_month}|selector|lov={sm_month_selector}|dropdown|width=100%|on_change=change_scenario_selector|>  |month>    <scenario|  Scenario    <|{selected_scenario}|selector|lov={scenario_selector}|dropdown|value_by_id|width=18rem|>  |scenario>  |>  |layout_scenario>    <|  **Table** \\n \\n <|{sm_graph_selected}|selector|lov={sm_graph_selector}|dropdown|>  |>    <br/>  <br/>  <|{d_chart_csv_path}|file_download|name=table.csv|label=Download table|>  |>    <|part|render={len(scenario_selector)>0}|partial={partial_table}|>    <|part|render=False|  <|{scenario_counter}|>  |>    \"\"\" "}
{"text": "import pandas as pd  import json    with open('data/fixed_variables_default.json', \"r\") as f:      fixed_variables_default = json.load(f)    # Taipy Core\uc758 \ucf54\ub4dc\ub294 \uc544\uc9c1 \uc2e4\ud589\ub418\uc9c0 \uc54a\uc558\uc2b5\ub2c8\ub2e4. csv \ud30c\uc77c\uc744 \uc774\ub7f0 \uc2dd\uc73c\ub85c \uc77d\uc2b5\ub2c8\ub2e4.  da_initial_demand = pd.read_csv('data/time_series_demand.csv')  da_initial_demand = da_initial_demand[['Year', 'Month', 'Demand_A', 'Demand_B']].astype(int)    da_initial_demand.columns = [col.replace('_', ' ')                               for col in da_initial_demand.columns]    da_initial_variables = pd.DataFrame({key: [fixed_variables_default[key]]                                      for key in fixed_variables_default.keys() if 'Initial' in key})    # \uc544\ub798 \ucf54\ub4dc\ub294 \uc5f4 \uc774\ub984\uc758 \ud615\uc2dd\uc744 \uc62c\ubc14\ub974\uac8c \uc9c0\uc815\ud558\ub294 \uac83\uc785\ub2c8\ub2e4.  da_initial_variables.columns = [col.replace('_', ' ').replace('one', '1').replace('two', '2').replace('initial ', '')                                  for col in da_initial_variables.columns]  da_initial_variables.columns = [col[0].upper() +                                  col[1:] for col in da_initial_variables.columns]      da_data_visualisation_md = \"\"\"  # \ub370\uc774\ud130 \uc2dc\uac01\ud654    <|Expand here|expanded=False|expandable|    <|layout|columns=1 1 1|columns[mobile]=1|  <|  ## \ucd08\uae30 \uc7ac\uace0    <center>  <|{da_initial_variables[[col for col in da_initial_variables.columns if 'Stock' in col]]}|table|show_all|width=445px|>  </center>  |>    <|  ## \ucd08\uae30 \uc0dd\uc0b0    <center>  <|{da_initial_variables[[col for col in da_initial_variables.columns if 'Production' in col]]}|table|show_all|width=445px|>  </center>  |>    <|  ## \uad6c\ub9e4\ud55c \uc790\ub8cc    <center>  <|{da_initial_variables[[col for col in da_initial_variables.columns if 'Purchase' in col]]}|table|show_all|width=445px|>  </center>  |>  |>      ## \ub2e4\uac00\uc624\ub294 \ub2ec\uc758 \uc218\uc694    <center>  <|{da_initial_demand.round()}|table|width=fit-content|show_all|height=fit-content|>  </center>  |>    ## \uc218\uc694\uc758 \uc9c4\ud654    <|{da_initial_demand}|chart|x=Month|y[1]=Demand A|y[2]=Demand B|width=100%|>  \"\"\" "}
{"text": "from data.create_data import time_series_to_csv  from config.config import scenario_cfg    from taipy.core import taipy as tp    import datetime as dt  import pandas as pd    cc_data = pd.DataFrame(      {          'Date': [dt.datetime(2021, 1, 1)],          'Cycle': [dt.date(2021, 1, 1)],          'Cost of Back Order': [0],          'Cost of Stock': [0]      })    cc_show_comparison = False  cc_layout = {'barmode': 'stack', 'margin': {\"t\": 20}}  cc_creation_finished = False      def cc_create_scenarios_for_cycle():      \"\"\"\uc774 \uae30\ub2a5\uc740 \uc5ec\ub7ec \uc8fc\uae30\uc5d0 \ub300\ud55c \uc2dc\ub098\ub9ac\uc624\ub97c \uc0dd\uc131\ud558\uace0 \uc81c\ucd9c\ud569\ub2c8\ub2e4.      \"\"\"      date = dt.datetime(2021, 1, 1)      month = date.strftime('%b')      year = date.strftime('%Y')        current_month = dt.date.today().strftime('%b')      current_year = dt.date.today().strftime('%Y')        while month != current_month or year != current_year:          date += dt.timedelta(days=15)          month = date.strftime('%b')          year = date.strftime('%Y')            if month != current_month or year != current_year:                time_series_to_csv(                  nb_months=12,                  mean_A=840,                  mean_B=760,                  std_A=96,                  std_B=72,                  amplitude_A=108,                  amplitude_B=144)                name = f\"Scenario {date.strftime('%d-%b-%Y')}\"              scenario = tp.create_scenario(scenario_cfg, creation_date=date, name=name)              tp.submit(scenario)      def update_cc_data(state):      \"\"\"\uc774 \uae30\ub2a5\uc740 \ubaa8\ub4e0 \uc8fc\uae30\uc758 \uae30\ubcf8 \uc2dc\ub098\ub9ac\uc624\uc5d0 \ub300\ud55c \uc774\uc6d4 \uc8fc\ubb38 \ubc0f \uc7ac\uace0 \ube44\uc6a9\uc758 \ubc1c\uc804\uc744 \ub9cc\ub4ed\ub2c8\ub2e4.\"\"\"      all_scenarios = tp.get_primary_scenarios()        dates = []      cycles = []      costs_of_back_orders = []      costs_of_stock = []        all_scenarios_ordered = sorted(          all_scenarios,          key=lambda x: x.creation_date.timestamp())  # delete?      for scenario in all_scenarios_ordered:            results = scenario.results.read()            if results is not None:              date_ = scenario.creation_date              dates.append(date_)              cycles.append(dt.date(date_.year, date_.month, 1))                # sum_costs_of_stock \uba54\ud2b8\ub9ad \uc0dd\uc131              bool_costs_of_stock = [c for c in results.columns                                     if 'Cost' in c and 'Total' not in c and 'Stock' in c]              sum_costs_of_stock = int(results[bool_costs_of_stock].sum(axis=1)\\                                                                   .sum(axis=0))                # sum_costs_of_BO \uc9c0\ud45c \uc0dd\uc131              bool_costs_of_BO = [c for c in results.columns                                  if 'Cost' in c and 'Total' not in c and 'BO' in c]              sum_costs_of_BO = int(results[bool_costs_of_BO].sum(axis=1)\\                                                             .sum(axis=0))                costs_of_back_orders.append(sum_costs_of_BO)              costs_of_stock.append(sum_costs_of_stock)        state.cc_data = pd.DataFrame({'Date': dates,                                    'Cycle': cycles,                                    'Cost of Back Order': costs_of_back_orders,                                    'Cost of Stock': costs_of_stock})        state.cc_show_comparison = True      cc_compare_cycles_md = \"\"\"  # \uc0ac\uc774\ud074 \ube44\uad50      <center>  <|Compare Cycles|button|on_action={update_cc_data}|>  </center>    <|part|render={cc_show_comparison}|  <|Table|expanded=False|expandable|    <center>  <|{cc_data}|table|width=fit-content|>  </center>    |>    ## \ube44\uc6a9\uc758 \uc9c4\ud654    <|{cc_data}|chart|type=bar|x=Cycle|y[1]=Cost of Back Order|y[2]=Cost of Stock|layout={cc_layout}|width=100%|height=600|>  |>    \"\"\" "}
{"text": "from .chart_md import ch_chart_md, ch_layout_dict, ch_results  from config.config import fixed_variables_default  from taipy.gui import Icon      def create_sliders(fixed_variables):      \"\"\"\"      \uc774\uac83\uc740 \ub9e4\uac1c\ubcc0\uc218\uc5d0 \ub300\ud55c \uc2ac\ub77c\uc774\ub354\ub97c \uc790\uccb4\uc801\uc73c\ub85c \uc0dd\uc131\ud558\ub294 \ub9e4\uc6b0 \ubcf5\uc7a1\ud55c \ud568\uc218\uc785\ub2c8\ub2e4.      \uc190\uc73c\ub85c \ud560 \uc218\ub3c4 \uc788\uc5c8\uc2b5\ub2c8\ub2e4. \uadf8\ub7ec\ub098 \uc774 \ubc29\ubc95\uc740 \uc7a5\uae30\uc801\uc73c\ub85c \ub354 \uc720\uc5f0\ud569\ub2c8\ub2e4.      \"\"\"            # \ubc18\ud658\ub420 \ubb38\uc790\uc5f4      slider_md = \"\"            # \ub9e4\uac1c\ubcc0\uc218\uc5d0\ub294 \uc138 \uac00\uc9c0 \uc720\ud615\uc774 \uc788\uc2b5\ub2c8\ub2e4.      param_types = ['Capacity Constraints','Objective Weights','Initial Parameters']      # \ub2e4\ub978 \uc81c\ud488\uc758 \uc2ac\ub77c\uc774\ub354\ub294 (\ud1a0\uae00\uc744 \uc0ac\uc6a9\ud558\uc5ec) \ub2e4\ub978 \uc139\uc158\uc73c\ub85c \uadf8\ub8f9\ud654\ub429\ub2c8\ub2e4.      products = ['FPA','FPB','RPone','RPtwo','weight']            for p_type in param_types:          # p_type\uc774 \uc120\ud0dd\ub418\uba74 \ud574\ub2f9 \ubd80\ubd84\uc774 \ud45c\uc2dc\ub429\ub2c8\ub2e4.          slider_md += \"\\n<|part|render={pa_param_selected == '\" + p_type + \"'}|\"          if p_type != 'Objective Weights':              # the part will be shown if 'Objective Weights' is not selected              slider_md +=\"\"\"  <center>  <|{pa_product_param}|toggle|lov={pa_choice_product_param}|value_by_id|>  </center>  <br/>  \"\"\"          if p_type == 'Objective Weights':              var_p = [key  for key in fixed_variables.keys() if ('produce' not in key and 'Weight' in key)]                            # \uac01 \ubcc0\uc218(var_p)\uc5d0 \ub300\ud574 \uc2ac\ub77c\uc774\ub354\uac00 \uc0dd\uc131\ub418\uace0 \uc788\uc2b5\ub2c8\ub2e4.              # \ucd5c\uc18c\uac12\uacfc \ucd5c\ub300\uac12\ub3c4 \uc790\ub3d9\uc73c\ub85c \uc0dd\uc131\ub429\ub2c8\ub2e4.              for var in var_p :                  min_ = str(int(fixed_variables[var]*0.35))                  max_ = str(int(fixed_variables[var]*1.65)) if fixed_variables[var] != 0 else '50'                                    name_of_var = var.replace('cost','Unit Cost -')                  name_of_var = name_of_var[0].upper() + name_of_var[1:].replace('_',' ').replace('one','1').replace('two','2')                                    slider_md += \"\\n\\n\" + name_of_var + \" : *<|{fixed_variables.\"+var+\"}|>*\"                  slider_md += \"\\n<|{fixed_variables.\"+var+\"}|slider|orientation=h|min=\"+min_+\"|max=\"+max_+\"|step=5|>\"          else :              # \uc81c\ud488\uc5d0 \ub530\ub77c \ubd80\ud488\uc774 \ud45c\uc2dc\ub429\ub2c8\ub2e4.              for p in products :                  slider_md += \"\\n<|part|render={pa_product_param == 'product_\"+p+\"'}|\"                  if p_type == 'Capacity Constraints':                      var_p = [key  for key in fixed_variables.keys() if (p in key and 'produce' not in key and 'Max' in key)]                  else :                      var_p = [key  for key in fixed_variables.keys() if (p in key and 'produce' not in key and 'Capacity' not in key and 'Max' not in key)]                                    # \uac01 \ubcc0\uc218(var_p)\uc5d0 \ub300\ud574 \uc2ac\ub77c\uc774\ub354\uac00 \uc0dd\uc131\ub418\uace0 \uc788\uc2b5\ub2c8\ub2e4.                  # \ucd5c\uc18c\uac12\uacfc \ucd5c\ub300\uac12\ub3c4 \uc790\ub3d9\uc73c\ub85c \uc0dd\uc131\ub429\ub2c8\ub2e4.                  for var in var_p :                      min_ = str(int(fixed_variables[var]*0.35))                      max_ = str(int(fixed_variables[var]*1.65)) if fixed_variables[var] != 0 else '50'                                            name_of_var = var.replace('cost','Unit Cost -')                      name_of_var = name_of_var[0].upper() + name_of_var[1:].replace('_',' ').replace('one','1').replace('two','2')                                            slider_md += \"\\n\\n\" + name_of_var + \" : *<|{fixed_variables.\"+var+\"}|>*\"                      slider_md += \"\\n<|{fixed_variables.\"+var+\"}|slider|orientation=h|min=\"+min_+\"|max=\"+max_+\"|step=5|>\"                                                                slider_md += \"\\n|>\"          slider_md+=\"\\n|>\"      return slider_md    pa_sliders_md = create_sliders(fixed_variables_default)    pa_parameters_md = \"\"\"  <|layout|columns=139 1 45|columns[mobile]=1|gap=1.5rem|  \"\"\" + ch_chart_md + \"\"\"     <blank_space|  |blank_space>    <|  <center>  <|{pa_param_selected}|selector|lov={pa_param_selector}|>  </center>    \"\"\" + pa_sliders_md + \"\"\"    <|Delete|button|on_action={delete_scenario_fct}|active={len(scenario_selector)>0}|id=delete_button|>  <|Make Primary|button|on_action={make_primary}|active={len(scenario_selector)>0 and not selected_scenario_is_primary}|id=make_primary|>  <|Re-optimize|button|on_action=submit_scenario|active={len(scenario_selector)>0}|id=re_optimize|>  <|New scenario|button|on_action=create_new_scenario|id=new_scenario|>  |>  |>  \"\"\"    pa_param_selector = ['Capacity Constraints','Objective Weights','Initial Parameters']  pa_param_selected = pa_param_selector[0]      # \uc2ac\ub77c\uc774\ub354 \uc120\ud0dd \ud1a0\uae00  pa_choice_product_param = [(\"product_RPone\", Icon(\"images/P1.png\", \"product_RPone\")),                      (\"product_RPtwo\", Icon(\"images/P2.png\", \"product_RPtwo\")),                      (\"product_FPA\", Icon(\"images/PA.png\", \"product_FPA\")),                      (\"product_FPB\", Icon(\"images/PB.png\", \"product_FPB\"))]  pa_product_param = 'Else'   "}
{"text": "from taipy.gui import Icon  import pandas as pd    ch_layout_dict = {\"margin\":{\"t\":20}}    # \ucc28\ud2b8 \uc124\uc815 \ud1a0\uae00  ch_choice_chart = [(\"pie\", Icon(\"images/pie.png\", \"pie\")),                      (\"chart\", Icon(\"images/chart.png\", \"chart\"))]  ch_show_pie = ch_choice_chart[1][0]    ch_results = pd.DataFrame({\"Monthly Production FPA\":[],                            \"Monthly Stock FPA\": [],                            \"Monthly BO FPA\": [],                            \"Max Capacity FPA\": [],                                                        \"Monthly Production FPB\": [],                            \"Monthly Stock FPB\": [],                            \"Monthly BO FPB\": [],                            \"Max Capacity FPB\": [],                                                        \"Monthly Stock RP1\":[],                            \"Monthly Stock RP2\":[],                                                        \"Monthly Purchase RP1\":[],                            \"Monthly Purchase RP2\":[],                                                        \"Demand FPA\": [],                            \"Demand FPB\": [],                                                        'Stock FPA Cost': [],                            'Stock FPB Cost': [],                                                        'Stock RP1 Cost': [],                            'Stock RP2 Cost': [],                                                        'Purchase RP1 Cost': [],                            'Purchase RP2 Cost': [],                                                        \"BO FPA Cost\":[],                            \"BO FPB Cost\":[],                                                        \"Total Cost\": [],                            \"index\": []})        def get_col(ch_results:pd.DataFrame,var:str):      if var == 'Cost':          columns = [col for col in ch_results.columns if var in col]      elif var=='Production':          columns = [col for col in ch_results.columns if (var in col or 'Capacity' in col) and 'Cost' not in col]      else :          columns = [col for col in ch_results.columns if var in col and 'Cost' not in col]                return columns      def get_y_format(columns):      md =\"\"      for col_i in range(len(columns)):          md+=f\"y[{col_i+1}]={columns[col_i]}|\"          if \"Capacity\" in columns[col_i] :              md+=f\"line[{col_i+1}]=dash|\"                return md[:-1]      def create_charts_md(ch_results):      \"\"\"\"      \uc774\uac83\uc740 \ubaa8\ub4e0 \ucc28\ud2b8\ub97c \uc0dd\uc131\ud558\ub294 \ub9e4\uc6b0 \ubcf5\uc7a1\ud55c \ud568\uc218\uc785\ub2c8\ub2e4.      \ub610\ud55c \uc0ac\uc6a9\uc790 \uc791\uc5c5\uc5d0 \ub530\ub77c \uc2dc\uac04\uc774 \uc9c0\ub0a8\uc5d0 \ub530\ub77c \ubcc0\uacbd\ub418\ub294 \ub2e8\uc77c \ubb38\uc790\uc5f4\uc744 \uac16\ub3c4\ub85d \uc218\ub3d9\uc73c\ub85c \uc218\ud589\ud558\uac70\ub098 \ubd80\ubd84\uc801\uc73c\ub85c \uc0ac\uc6a9\ud560 \uc218 \uc788\uc2b5\ub2c8\ub2e4.      \"\"\"            # \ucc28\ud2b8\uc6a9 md\ub97c \ub9cc\ub4dc\ub294 \ub9e4\uac1c\ubcc0\uc218      config_scenario_option = [\"sm_show_config_scenario\", \"not(sm_show_config_scenario)\"]            # \ud30c\uc774\ub294 \uc774\ub7ec\ud55c \ud45c\ud604\uc5d0 \uac00\ub2a5\ud569\ub2c8\ub2e4.      pie_possible = ['Costs','Purchases','Productions','Stocks','Back Order']      charts_option_for_col = ['Cost','Purchase','Production','Stock','BO','FPA','FPB','RP1','RP2']      charts_option = ['Costs','Purchases','Productions','Stocks','Back Order','Product FPA','Product FPB','Product RP1','Product RP2']            md = \"\"      for config_scenario in config_scenario_option :          md += \"\\n<|part|render={\"+config_scenario+\"}|\"          md += \"\\n<|\"                        for charts_i in range(len(charts_option)):              columns = get_col(ch_results,charts_option_for_col[charts_i])              y_format = get_y_format(columns)              columns = [c for c in columns if 'Total' not in c] # in the pie, we don't want to show the total                            if charts_option[charts_i] in pie_possible :                  md +=\"\\n<|{pie_results.loc[\" + str(columns) + \"]}|chart|type=pie|x=values|label=labels|width={width_chart}|height={height_chart}|layout={ch_layout_dict}|render={ch_show_pie=='pie' and sm_graph_selected=='\"+charts_option[charts_i]+\"'}|>\"                  md += \"\\n<|{ch_results}|chart|x=index|\" + y_format + \"|width={width_chart}|height={height_chart}|layout={ch_layout_dict}|render={ch_show_pie=='chart' and sm_graph_selected=='\"+charts_option[charts_i]+\"'}|>\"              else:                  md += \"\\n<|{ch_results}|chart|x=index|\" + y_format + \"|width={width_chart}|height={height_chart}|layout={ch_layout_dict}|render={sm_graph_selected=='\"+charts_option[charts_i]+\"'}|>\"            md += \"\"\"\\n|>  |>\"\"\"        return md      ch_chart_md_1 = \"\"\"  <br/>  <|layout|columns=1 1|columns[mobile]=1|  <|  <center>  <|{str(int(sum_costs_of_BO/1000))+' K'}|indicator|value={sum_costs_of_BO}|min=50_000|max=1_000|width=93%|>  Back Order Cost  </center>  |>    <|  <center>  <|{str(int(sum_costs_of_stock/1000))+' K'}|indicator|value={sum_costs_of_stock}|min=100_000|max=25_000|width=93%|>  Stock Cost  </center>  |>  |>  \"\"\"    ch_chart_md = \"\"\"  <|  <|part|render={len(scenario_selector)>0}|  <|\"\"\" + ch_chart_md_1 + \"\"\"|>  \"\"\" + create_charts_md(ch_results) + \"\"\"  |>    <no_scenario|part|render={len(scenario_selector)==0}|  ## No scenario created for the current month  |no_scenario>  |>  \"\"\"         "}
{"text": "import taipy as tp  from taipy.gui import Icon      import datetime as dt  import os  import hashlib  import json        login = ''  password = ''  dialog_login = False  dialog_new_account = False  new_account = False    all_scenarios = tp.get_scenarios()    users = {}  json.dump(users, open('login/login.json', 'w'))    dialog_user = True  user_selector = [('Create new user',Icon('/images/new_account.png','Create new user'))]  user_in_session = ''  selected_user = None    salt = os.urandom(32)      def open_dialog_user(state):      state.login = ''      state.dialog_user = True      def encode(password):      key = str(hashlib.pbkdf2_hmac(          'sha256',  # The hash digest algorithm for HMAC          password.encode('utf-8'),  # Convert the password to bytes          salt,  # Provide the salt          100000,  # It is recommended to use at least 100,000 iterations of SHA-256          dklen=128  # Get a 128 byte key      ))      return key      def test_password(users, login, new_password):      old_key = users[login]['password']        new_key = str(hashlib.pbkdf2_hmac(          'sha256',  # The hash digest algorithm for HMAC          new_password.encode('utf-8'),  # Convert the password to bytes          salt,  # Provide the salt          100000,  # It is recommended to use at least 100,000 iterations of SHA-256          dklen=128  # Get a 128 byte key      ))        return old_key == new_key      def detect_inactive_session(state):      users[state.login]['last_visit'] = str(dt.datetime.now())      json.dump(users, open('login/login.json', 'w'))        for user in users.keys():          if (dt.datetime.now() - dt.datetime.strptime(users[user]['last_visit'],                                                      '%Y-%m-%d %H:%M:%S.%f')).seconds >= 6 * 3600:              [tp.delete(s.id) for s in tp.get_scenarios()               if 'user' in s.properties and users[user] == s.properties['user']]              users.pop(user)      login_md = \"\"\"  <|part|id=part_dialog_button|  Welcome, <|{login if login != '' else 'login'}|button|on_action={open_dialog_user}|id=dialog_button|>!  |>    <|{dialog_user}|dialog|title=Set account|id=dialog_user|width=20%|  <|{selected_user}|selector|lov={user_selector}|on_change=on_change_user_selector|id=user_selector|width=100%|value_by_id|>  |>    <|{dialog_login}|dialog|title=Login|on_action=validate_login|labels=Cancel; Login|id=dialog_user|width=20%|    <|{selected_user}|selector|lov={[(login, Icon('/images/user.png', login))]}|id=user_selected|width=100%|value_by_id|>    Password    <|{password}|input|password=True|>  |>        <|{dialog_new_account}|dialog|title=Register|on_action=validate_login|labels=Cancel; Register|id=dialog_user|width=20%|    Username <|{login}|input|>    Password <|{password}|input|password=True|>  |>      <|part|render={1==0}|  <|{user_in_session}|>  |>  \"\"\""}
{"text": "from taipy import Gui    page = \"\"\"  # Hello World \ud83c\udf0d with *Taipy*    This is my first Taipy test app.    And it is running fine!  \"\"\"    Gui(page).run(use_reloader=True)  # use_reloader=True if you are in development "}
{"text": "from taipy import Gui  from page.dashboard_fossil_fuels_consumption import *    if __name__ == \"__main__\":      Gui(page).run(          use_reloader=True,          title=\"Test\",          dark_mode=False,      )  # use_reloader=True if you are in development"}
{"text": "import pandas as pd  import taipy as tp    from data.data import dataset_fossil_fuels_gdp    country = \"Spain\"  region = \"Europe\"  lov_region = list(dataset_fossil_fuels_gdp.Entity.unique())      def load_dataset(_country):      \"\"\"Load dataset for a specific country.        Args:          _country (str): The name of the country.        Returns:          pandas.DataFrame: A DataFrame containing the fossil fuels GDP data for the specified country.      \"\"\"      dataset_fossil_fuels_gdp_cp = dataset_fossil_fuels_gdp.reset_index()        dataset_fossil_fuels_gdp_cp = dataset_fossil_fuels_gdp_cp[          dataset_fossil_fuels_gdp[\"Entity\"] == _country      ]      return dataset_fossil_fuels_gdp_cp      dataset_fossil_fuels_gdp_cp = load_dataset(country)      def on_change_country(state):      \"\"\"Update the dataset based on the selected country.        Args:          state (object): The \"state\" of the variables ran by the program (value changes through selectors)        Returns:          None      \"\"\"      print(\"country is:\", state.country)      _country = state.country      dataset_fossil_fuels_gdp_cp = load_dataset(_country)      state.dataset_fossil_fuels_gdp_cp = dataset_fossil_fuels_gdp_cp      layout = {\"yaxis\": {\"range\": [0, 100000]}, \"xaxis\": {\"range\": [1965, 2021]}}    page = \"\"\"  # Fossil Fuel consumption by per capita by country*    Data comes from <a href=\"https://ourworldindata.org/grapher/per-capita-fossil-energy-vs-gdp\" target=\"_blank\">Our World in Data</a>    <|{country}|selector|lov={lov_region}|on_change=on_change_country|dropdown|label=Country/Region|>        <|{dataset_fossil_fuels_gdp_cp}|chart|type=plot|x=Year|y=Fossil fuels per capita (kWh)|height=200%|layout={layout}|>    ## Fossil fuel per capita for <|{country}|>:  <|{dataset_fossil_fuels_gdp_cp}|table|height=400px|width=95%|>      \"\"\" "}
{"text": "import pandas as pd      dataset_fossil_fuels_gdp = pd.read_csv(\"data/per-capita-fossil-energy-vs-gdp.csv\")  country_codes = pd.read_csv(\"./data/country_codes.csv\")    dataset_fossil_fuels_gdp = dataset_fossil_fuels_gdp.merge(      country_codes[[\"alpha-3\", \"region\"]], how=\"left\", left_on=\"Code\", right_on=\"alpha-3\"  )    dataset_fossil_fuels_gdp = dataset_fossil_fuels_gdp[      ~dataset_fossil_fuels_gdp[\"Fossil fuels per capita (kWh)\"].isnull()  ].reset_index()    dataset_fossil_fuels_gdp[\"Fossil fuels per capita (kWh)\"] = (      dataset_fossil_fuels_gdp[\"Fossil fuels per capita (kWh)\"] * 1000  ) "}
{"text": "from taipy.gui import Gui as tpGui  from taipy.gui import notify as tpNotify    import pandas as pd    text = \"Original text\"  col1 = \"first col\"  col2 = \"second col\"  col3 = \"third col\"    ballon_img = \"./img/Ballon_15_20.png\"    section_1 = \"\"\"  <h1 align=\"center\">Getting started with Taipy GUI</h1>    <|layout|columns=1 2 2|  <|  My text: <|{text}|>  <|{text}|input|>  |>    <|  <center>  <|Press Me|button|on_action=on_button_action|>    **Ein Button:** <|{col1}|>  </center>  |>    <|  <center>  <|{ballon_img}|image|height=30%|width=30%|label=This is one ballon|>  </center>  |>    |>  \"\"\"    section_2 = '''    ##Darstellung Gas-Verbrauch  <|{dataset}|chart|mode=line|x=Datum|y[1]=Verbrauch|y[2]=Betriebsstunden|yaxis[2]=y2|layout={layout}|color[1]=green|color[2]=blue|>    '''  layout = {      \"xaxis\": {          # Force the title of the x axis          \"title\": \"Time-Range\"      },      \"yaxis\": {          # Force the title of the first y axis          \"title\": \"Verbrauch\",          # Place the first axis on the left          \"side\": \"left\"      },      \"yaxis2\": {          # Second axis overlays with the first y axis          \"overlaying\": \"y\",          # Place the second axis on the right          \"side\": \"right\",          # and give it a title          \"title\": \"Betriebsstunden\"      },      \"legend\": {          # Place the legend above chart          \"yanchor\": \"middle\"      }  }    def on_button_action(state):      tpNotify(state, 'info', f'The text is: {state.text}')      state.text = \"Button Pressed\"    def on_change(state, var_name, var_value):      if var_name == \"text\" and var_value == \"Reset\":          state.text = \"\"          return        def get_data(path: str):      dataset = pd.read_csv(path)      dataset[\"Datum\"] = pd.to_datetime(dataset[\"Datum\"], dayfirst=True).dt.date      return dataset    gui = tpGui(page=section_1 + section_2)  dataset = get_data(\"./dataset.csv\")    if __name__ == '__main__':      # Execute by the _Python_ interpretor, for debug only.      tpGui.run(gui, title=\"Taipy Demo\", use_reloader=True, dark_mode=True, port=5001, flask_log=False)  else:      # Execute by _Gunicorn_, for production environment.      app = tpGui.run(gui, title=\"Taipy Demo\", run_server=False) "}
{"text": "import os  import logging  from opentelemetry import metrics  from opentelemetry import trace  from opentelemetry.sdk.metrics import MeterProvider  from opentelemetry.sdk.resources import Resource, SERVICE_NAME  from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter  from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter  from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader  from opentelemetry.sdk.trace import TracerProvider  from opentelemetry.sdk.trace.export import (      BatchSpanProcessor,  )    logging.basicConfig(level=logging.DEBUG)      service_name = os.environ.get(\"OTEL_SERVICE_NAME\", __file__)  otel_endpoint = os.environ.get(\"OTEL_EXPORTER_OTLP_ENDPOINT\", \"localhost:4317\")    resource = Resource(attributes={SERVICE_NAME: service_name})      ###### Metrics  metrics_reader = PeriodicExportingMetricReader(      OTLPMetricExporter(endpoint=otel_endpoint)  )  metrics_provider = MeterProvider(metric_readers=[metrics_reader], resource=resource)  # Set the global default metrics provider  metrics.set_meter_provider(metrics_provider)    ###### Traces  trace_provider = TracerProvider()  processor = BatchSpanProcessor(OTLPSpanExporter(endpoint=otel_endpoint))  trace_provider.add_span_processor(processor)  # Sets the global default tracer provider  trace.set_tracer_provider(trace_provider)    meter = metrics.get_meter_provider().get_meter(\"my.meter.name\")  tracer = trace.get_tracer(\"my.tracer.name\")      def init_metrics() -> dict:      \"\"\"Initializes metrics\"\"\"      scenario_execution_counter = meter.create_counter(          \"scenario_execution\",          unit=\"counts\",          description=\"Counts the total number of times we execute a scenario\",      )        rec_svc_metrics = {\"scenario_execution_counter\": scenario_execution_counter}      return rec_svc_metrics "}
{"text": "import time  from pathlib import Path  from taipy import Config, Status  import taipy as tp  from taipy.gui import get_state_id, invoke_callback    from metrics import init_metrics, tracer      # Telemetry  rec_svc_metrics = init_metrics()      @tracer.start_as_current_span(\"function_double\")  def double(nb):      \"\"\"Double the given number.\"\"\"      time.sleep(1)      return int(nb) * 2      Config.load(Path(__file__).parent / \"config.toml\")  SCENARIO = Config.scenarios[\"my_scenario\"]  # pylint: disable=no-member      value = 21  # pylint: disable=invalid-name  result = double(value)  # pylint: disable=invalid-name    CONTENT = \"\"\"  * You can double this number: <|{value}|input|propagate=True|>  * by clicking on this button: <|Double it!|button|on_action=on_button_click|>  * and here is the result: <|{result}|>  \"\"\"  gui = tp.Gui(page=CONTENT)  core = tp.Core()      def job_updated(state_id, scenario, job):      \"\"\"Callback called when a job has been updated.\"\"\"      if job.status == Status.COMPLETED:            def _update_result(state, output):              state.result = output.read()            # invoke_callback allows to run a function with a GUI _state_.          invoke_callback(gui, state_id, _update_result, args=[scenario.output])            # Telemetry          rec_svc_metrics[\"scenario_execution_counter\"].add(              1, {\"execution_type\": \"manual\", \"scenario_name\": scenario.config_id}          )      def on_button_click(state):      \"\"\"callback for button clicked\"\"\"      state_id = get_state_id(state)      my_scenario = tp.create_scenario(SCENARIO)      my_scenario.input.write(state.value)      tp.subscribe_scenario(scenario=my_scenario, callback=job_updated, params=[state_id])      tp.submit(my_scenario)      if __name__ == \"__main__\":      tp.run(          gui,          core,          host=\"0.0.0.0\",          title=\"Basic Taipy App\",      ) "}
{"text": "from taipy.gui import Gui  from tensorflow.keras import models  from PIL import Image  import numpy as np      class_names = {      0: 'airplane',      1: 'automobile',      2: 'bird',      3: 'cat',      4: 'deer',      5: 'dog',      6: 'frog',      7: 'horse',      8: 'ship',      9: 'truck',  }    model = models.load_model(\"baseline_mariya.keras\")      def predict_image(model, path_to_img):      img = Image.open(path_to_img)      img = img.convert(\"RGB\")      img = img.resize((32, 32))      data = np.asarray(img)      # print(\"before:\",data[0][0])      data = data / 255      # print(\"after:\",data[0][0])      probs = model.predict(np.array([data])[:1])      # print(probs)      # print(probs.max())      top_prob = probs.max()      # print(np.argmax(probs))      top_pred = class_names[np.argmax(probs)]      return top_prob, top_pred      content = \"\"  img_path = \"placeholder_image.png\"  prob = 0  pred = \"\"    index = \"\"\"  <|text-center|  <|{\"logo.png\"}|image|width = 25vw|>    <|{content}|file_selector|extensions = .png|>  select an image from your file system    <|{pred}|>    <|{img_path}|image|>    <|{prob}|indicator|value = {prob}|min = 0|max = 100|width = 25vw|>  |>  \"\"\"      def on_change(state, var_name, var_val):      if var_name == \"content\":          top_prob, top_pred = predict_image(model, var_val)          state.prob = round(top_prob * 100)          state.pred = \"This is a \" + top_pred          state.img_path = var_val      # print(var_name,var_val)      app = Gui(page=index)    if __name__ == \"__main__\":      app.run() "}
{"text": "def a   "}
{"text": "import os  import threading    from flask import Flask  from pyngrok import ngrok  from hf_hub_ctranslate2 import GeneratorCT2fromHfHub    from flask import request, jsonify    model_name = \"taipy5-ct2\" # note this is local folder model, the model uploaded to huggingface did not response correctly  #model_name = \"michaelfeil/ct2fast-starchat-alpha\"  #model_name = \"michaelfeil/ct2fast-starchat-beta\"  model = GeneratorCT2fromHfHub(          # load in int8 on CUDA          model_name_or_path=model_name,          device=\"cuda\",          compute_type=\"int8_float16\",          # tokenizer=AutoTokenizer.from_pretrained(\"{ORG}/{NAME}\")  )    def generate_text_batch(prompt_texts, max_length=64):      outputs = model.generate(prompt_texts, max_length=max_length, include_prompt_in_result=False)      return outputs    app = Flask(__name__)  port = \"5000\"    # Open a ngrok tunnel to the HTTP server  public_url = ngrok.connect(port).public_url  print(\" * ngrok tunnel \\\"{}\\\" -> \\\"http://127.0.0.1:{}\\\"\".format(public_url, port))    # Update any base URLs to use the public ngrok URL  app.config[\"BASE_URL\"] = public_url    # ... Update inbound traffic via APIs to use the public-facing ngrok URL  # Define Flask routes  @app.route(\"/\")  def index():      return \"Hello from Colab!\"    @app.route(\"/api/generate\", methods=[\"POST\"])  def generate_code():      try:          # Get the JSON data from the request body          data = request.get_json()                    # Extract 'inputs' and 'parameters' from the JSON data          inputs = data.get('inputs', \"\")          parameters = data.get('parameters', {})                    # Extract the 'max_new_tokens' parameter          max_new_tokens = parameters.get('max_new_tokens', 64)            # Call the generate_text_batch function with inputs and max_new_tokens          generated_text = generate_text_batch([inputs], max_new_tokens)[0]            return jsonify({          \"generated_text\": generated_text,          \"status\": 200          })        except Exception as e:          return jsonify({\"error\": str(e)})      # Start the Flask server in a new thread  threading.Thread(target=app.run, kwargs={\"use_reloader\": False}).start() "}
{"text": ""}
{"text": "#Imports  from taipy.gui import Gui  from tensorflow.keras import models  from PIL import Image  import numpy as np    #Variables  classes = {      0: 'airplane',      1: 'automobile',      2: 'bird',      3: 'cat',      4: 'deer',      5: 'dog',      6: 'frog',      7: 'horse',      8: 'ship',      9: 'truck'  }      model = models.load_model(\"baseline_model.keras\")    content=\"\"  img_path = 'placeholder_image.png'  prob = 0  pred = \"\"  #Define model prediction function    def predict_image(model, path):      img = Image.open(path)      img = img.convert(\"RGB\")       img = img.resize((32, 32))      data = np.asarray(img)      data = data / 255      data = np.array([data])      probs = model.predict(data)        top_prob = probs.max()      top_pred = classes.get(np.argmax(probs))      return top_prob, top_pred        #Define the app as a Gui  index = \"\"\"  <|text-center|  <|{\"logo.png\"}|image|>    <|{content}|file_selector|extensions=.png|>   Select an image to classify     <|{pred}|>    <|{img_path}|image|>    <|{prob}|indicator|value={prob}|min=0|max=100|width=22vw|>  >  \"\"\"    def on_change(state, var, val):      if var == \"content\":          top_prob, top_pred = predict_image(model, val)                    state.img_path = val          state.prob = round(top_prob * 100)          state.pred = f\"This is a {top_pred}\"      #print(state,var,val)  app = Gui(page = index)    #Run script  if __name__ ==\"__main__\":      app.run(use_reloader=True) "}
{"text": "from taipy.gui import Gui, notify  import pandas as pd  import webbrowser  import datetime  import os    DOWNLOAD_PATH = \"data/download.csv\"  upload_file = None    section_1 = \"\"\"  <center>  <|navbar|lov={[(\"page1\", \"This Page\"), (\"https://docs.taipy.io/en/latest/manuals/about/\", \"Taipy Docs\"), (\"https://docs.taipy.io/en/latest/getting_started/\", \"Getting Started\")]}|>  </center>    Data Dashboard with Taipy  =========================  <|layout|columns=1 3|  <|  ### Let's create a simple Data Dashboard!  <br/>   <center>      <|{upload_file}|file_selector|label=Upload Dataset|>  </center>  |>  <|  <center>      <|{logo}|image|height=250px|width=250px|on_action=image_action|>  </center>  |>  |>  \"\"\"    section_2 = \"\"\"  ## Data Visualization  <|{dataset}|chart|mode=lines|x=Date|y[1]=MinTemp|y[2]=MaxTemp|color[1]=blue|color[2]=red|>  \"\"\"    section_3 = \"\"\"  <|layout|columns= 1 5|  <|  ## Custom Parameters  **Starting Date**\\n\\n<|{start_date}|date|not with_time|on_change=start_date_onchange|>  <br/><br/>  **Ending Date**\\n\\n<|{end_date}|date|not with_time|on_change=end_date_onchange|>  <br/>  <br/>  <|button|label=GO|on_action=button_action|>  |>  <|  <center>      <h2>Dataset</h2><|{DOWNLOAD_PATH}|file_download|on_action=download|>      <|{dataset}|table|page_size=10|height=500px|width=65%|>  </center>  |>  |>  \"\"\"  def image_action(state):      webbrowser.open(\"https://taipy.io\")    def get_data(path: str):      dataset = pd.read_csv(path)      dataset[\"Date\"] = pd.to_datetime(dataset[\"Date\"]).dt.date      return dataset    def start_date_onchange(state, var_name, value):      state.start_date = value.date()    def end_date_onchange(state, var_name, value):      state.end_date = value.date()    def filter_by_date_range(dataset, start_date, end_date):      mask = (dataset['Date'] > start_date) & (dataset['Date'] <= end_date)      return dataset.loc[mask]    def button_action(state):      state.dataset = filter_by_date_range(dataset, state.start_date, state.end_date)      notify(state, \"info\", \"Updated date range from {} to {}.\".format(state.start_date.strftime(\"%m/%d/%Y\"), state.end_date.strftime(\"%m/%d/%Y\")))    def download(state):      state.dataset.to_csv(DOWNLOAD_PATH)    logo = \"images/taipy_logo.jpg\"  dataset = get_data(\"data/weather.csv\")  start_date = datetime.date(2008, 12, 1)  end_date = datetime.date(2017, 6, 25)    gui = Gui(page=section_1+section_2+section_3)    if __name__ == '__main__':      # the options in the gui.run() are optional, try without them      gui.run(title='Taipy Demo GUI 2',      \t\thost='0.0.0.0',      \t\tport=os.environ.get('PORT', '5050'),      \t\tdark_mode=False)  else:      app = gui.run(title='Taipy Demo GUI 2',                    dark_mode=False,                    run_server=False)"}
{"text": "from taipy.gui import Gui    from pages.all_regions import *  from pages.by_region import *    # Toggle theme: switch dark/light mode  root_md = \"\"\"  <|toggle|theme|>  <center>\\n<|navbar|>\\n</center>  \"\"\"    stylekit = {      \"color-primary\": \"#CC3333\",      \"color-secondary\": \"#E0C095\",      \"color-background-light\": \"#F7E7CE\",      \"color-background-dark\": \"#E0C095\",  }    pages = {\"/\": root_md, \"all_regions\": all_regions_md, \"by_region\": by_region_md}      gui_multi_pages = Gui(pages=pages)    if __name__ == \"__main__\":      gui_multi_pages.run(          use_reloader=True,          title=\"Wine \ud83c\udf77 production by Region and Year\",          dark_mode=False,          stylekit=stylekit,      ) "}
{"text": "import geopandas as gpd  import pandas as pd      def add_basic_stats(df_wine: pd.DataFrame) -> pd.DataFrame:      \"\"\"Add basic statistics to a DataFrame containing wine production data.        This function calculates the minimum, maximum, and average wine production values for each row      in the input DataFrame based on yearly data. The resulting DataFrame includes three additional      columns: 'min', 'max', and 'average'.        Args:          df_wine (pd.DataFrame): A DataFrame containing wine production data for various French wine regions.        Returns:          df_wine_with_stats (pd.DataFrame): A new DataFrame with additional columns ('min', 'max', 'average')              representing the calculated statistics for each row.      \"\"\"      df_wine_with_stats = df_wine.copy()      df_wine_years = df_wine_with_stats[          [              \"08/09\",              \"09/10\",              \"10/11\",              \"11/12\",              \"12/13\",              \"13/14\",              \"14/15\",              \"15/16\",              \"16/17\",              \"17/18\",              \"18/19\",          ]      ]        df_wine_with_stats[\"min\"] = df_wine_years.min(axis=1)      df_wine_with_stats[\"max\"] = df_wine_years.max(axis=1)      df_wine_with_stats[\"average\"] = round(df_wine_years.mean(axis=1), 2)        # Rename the \"wine_basin\" column for better readability in the dashboard      df_wine_with_stats = df_wine_with_stats.rename(columns={\"wine_basin\": \"Region\"})      return df_wine_with_stats      def add_geometry(      df_wine_with_stats: pd.DataFrame, geometry: pd.DataFrame  ) -> pd.DataFrame:      \"\"\"Add geographical information to a DataFrame containing wine production statistics.        This function takes a DataFrame with wine production statistics (`df_wine_with_stats`)      and a DataFrame with geographical information (`geometry`). It adds geographical data to      the wine production DataFrame (including latitude and longitude).        Args:          df_wine_with_stats (pd.DataFrame): DataFrame containing wine production statistics              for various regions and wine types.          geometry (pd.DataFrame): DataFrame with geometrical information, including the              'geometry' column containing the geographical shapes.        Returns:          df_wine_with_geometry (pd.DataFrame): A new DataFrame with additional geographical information,              including latitude and longitude, added to the wine production data.      \"\"\"      df_geometry = gpd.GeoDataFrame.from_features(geometry, crs=3857)      # Reproject to EPSG:4326 to be able to extract Lon and Lat      df_geometry = df_geometry.to_crs(epsg=4326)      df_wine_with_geometry = df_wine_with_stats.copy()        # Drop the rows that are subsets (so we don't count in aggregation)      rows_to_drop = df_wine_with_geometry[\"AOC\"].str.contains(\"(subset)\")      df_wine_with_geometry = df_wine_with_geometry.drop(          df_wine_with_geometry[rows_to_drop].index      )      df_wine_with_geometry = df_wine_with_geometry.reset_index(drop=True)        # Drop the \"AOC\" column, as well as \"min\" and \"max\"      df_wine_with_geometry = df_wine_with_geometry.drop([\"AOC\", \"min\", \"max\"], axis=1)        df_wine_with_geometry = df_wine_with_geometry.groupby([\"Region\", \"wine_type\"]).sum()      df_wine_with_geometry = df_wine_with_geometry.reset_index()      df_wine_with_geometry = df_wine_with_geometry.sort_values(          by=[\"average\"], ascending=False      ).reset_index(drop=True)        # Extract latitude and longitude      df_geometry[\"latitude\"] = df_geometry[\"geometry\"].y      df_geometry[\"longitude\"] = df_geometry[\"geometry\"].x      df_geometry = df_geometry.drop(\"geometry\", axis=1)        df_wine_with_geometry = pd.merge(          df_wine_with_geometry, df_geometry, left_on=\"Region\", right_on=\"Bassin\"      )      df_wine_with_geometry = df_wine_with_geometry.drop(\"Bassin\", axis=1)      return df_wine_with_geometry "}
{"text": "import taipy.core as tp  from taipy import Config    # Loading of the TOML  Config.load(\"config/taipy-config.toml\")  tp.Core().run()    # Get the scenario configuration  scenario_cfg = Config.scenarios[\"SC_WINE\"]    sc_wine = tp.create_scenario(scenario_cfg)  sc_wine.submit()    df_wine_production = sc_wine.WINE_PRODUCTION_WITH_STATS.read()  df_wine_with_geometry = sc_wine.WINE_PRODUCTION_WITH_GEOMETRY.read() "}
{"text": "from typing import Any, Tuple    import pandas as pd    from config.config import df_wine_with_geometry    list_of_regions = df_wine_with_geometry[\"Region\"].unique().tolist()  selected_region = \"SUD-OUEST\"      def clean_df_region_color(df_region_color: pd.DataFrame) -> pd.DataFrame:      \"\"\"Clean and transform a DataFrame containing region color information.        This function takes a DataFrame (`df_region_color`) containing color information for a specific      wine region. It performs cleaning operations, including dropping unnecessary columns and      transposing the DataFrame for better representation.        Args:          df_region_color (pd.DataFrame): DataFrame containing color information for a specific wine region.        Returns:          pd.DataFrame: A cleaned and transformed DataFrame with columns 'Harvest' and 'years'.      \"\"\"      df_region_color_clean = df_region_color.drop(          [\"Region\", \"wine_type\", \"average\", \"latitude\", \"longitude\"], axis=1      )        years = df_region_color_clean.columns      df_region_color_clean = df_region_color_clean.transpose().rename(          columns={0: \"Harvest\"}      )      df_region_color_clean[\"Harvest\"] = df_region_color_clean[\"Harvest\"] / 10      df_region_color_clean[\"years\"] = years      return df_region_color_clean      def create_df_region(selected_region: str) -> Tuple[pd.DataFrame, pd.DataFrame]:      \"\"\"Create DataFrames for red and white wine production statistics for a selected region.        This function takes a selected region (`selected_region`) and extracts relevant information      from the original wine production DataFrame (`df_wine_with_geometry`). It creates separate      DataFrames for red and white wine production, applying additional cleaning operations.        Args:          selected_region (str): The selected wine region.        Returns:          Tuple[pd.DataFrame, pd.DataFrame]: A tuple containing two DataFrames - one for red wine ('df_region_red')          and one for white wine ('df_region_white').      \"\"\"      df_region = df_wine_with_geometry.copy()      df_region = df_region[df_region[\"Region\"] == selected_region]        df_region_red = df_region[df_region[\"wine_type\"] == \"RED AND ROSE\"].reset_index(          drop=True      )      df_region_white = df_region[df_region[\"wine_type\"] == \"WHITE\"].reset_index(          drop=True      )      if selected_region not in (\"CHAMPAGNE\", \"ALSACE ET EST\"):          df_region_red = clean_df_region_color(df_region_red)      else:          df_region_red = pd.DataFrame.from_dict(              {                  \"Harvest\": [0] * 10,                  \"years\": [                      \"08/09\",                      \"09/10\",                      \"10/11\",                      \"11/12\",                      \"12/13\",                      \"13/14\",                      \"14/15\",                      \"15/16\",                      \"17/18\",                      \"18/19\",                  ],              }          )      df_region_white = clean_df_region_color(df_region_white)      return (df_region_red, df_region_white)      df_region_red, df_region_white = create_df_region(selected_region)      def on_change_region(state: Any) -> None:      \"\"\"Update red and white wine DataFrames based on a change in the selected region.        This function takes the current state (`state`) and updates the red and white wine      DataFrames (`df_region_red` and `df_region_white`) based on a change in the selected region.        Args:          state (Any): The current state object.        Returns:          None      \"\"\"      state.df_region_red, state.df_region_white = create_df_region(state.selected_region)      ##############################################################################################################  ##                                      Chart properties:                                                   ##  ##############################################################################################################    plot_chart_layout = {\"yaxis\": {\"range\": [0, 600]}}    property_plot_white = {      \"type\": \"scatter\",      \"mode\": \"lines\",      \"x\": \"years\",      \"y\": \"Harvest\",      \"color\": \"#E0C095\",      \"title\": f\"Production of White wines (Million Liters)\",  }    property_plot_red = {      \"type\": \"scatter\",      \"mode\": \"lines\",      \"x\": \"years\",      \"y\": \"Harvest\",      \"color\": \"#900020\",      \"title\": f\"Production of Red wines (Million Liters)\",  }    ##############################################################################################################  ##                                      Taipy Code:                                                         ##  ##############################################################################################################    by_region_md = \"\"\"    <|layout|columns= 1 2|    <|{selected_region}|selector|lov={list_of_regions}|on_change=on_change_region|dropdown|label=Choose Region|>  # Wine production | **by Region**{: .color-primary}  |>    # Charts:    <|layout|columns= 1 1|  <|{df_region_red}|chart|properties={property_plot_red}|layout={plot_chart_layout}|>    <|{df_region_white}|chart|properties={property_plot_white}|layout={plot_chart_layout}|>  |>  \"\"\" "}
{"text": "import numpy as np    from taipy.gui import Gui    from pages.country import country_md, on_change_country,\\                            selected_representation, data_country_date, pie_chart  from pages.world import world_md  from pages.map import map_md  from pages.predictions import predictions_md, selected_scenario, result, scenario_country, scenario_date    from data.data import data    selector_country = list(np.sort(data['Country/Region'].astype(str).unique()))  selected_country = 'France'    pages = {      \"/\":\"<center><|navbar|></center>\",      \"Country\":country_md,      \"World\":world_md,      \"Map\":map_md,      \"Predictions\":predictions_md  }      if __name__ == '__main__':      gui_multi_pages = Gui(pages=pages)        gui_multi_pages.run(title=\"Covid Dashboard\",      \t\t            dark_mode=False,                          use_reloader=False,                          port=5039)"}
{"text": "from taipy.config import Config, Scope  import datetime as dt    from algos.algos import add_features, create_train_data, preprocess,\\                          train_arima, train_linear_regression,\\                          forecast, forecast_linear_regression,\\                          result    #Config.configure_job_executions(mode=\"standalone\", nb_of_workers=2)    path_to_data = \"data/covid-19-all.csv\"    initial_data_cfg = Config.configure_data_node(id=\"initial_data\",                                                storage_type=\"csv\",                                                path=path_to_data,                                                cacheable=True,                                                validity_period=dt.timedelta(days=5),                                                scope=Scope.GLOBAL)    country_cfg = Config.configure_data_node(id=\"country\", default_data=\"France\",                                           cacheable=True, validity_period=dt.timedelta(days=5))      date_cfg = Config.configure_data_node(id=\"date\", default_data=dt.datetime(2020,10,1),                                           cacheable=True, validity_period=dt.timedelta(days=5))    final_data_cfg =  Config.configure_data_node(id=\"final_data\",                                              cacheable=True, validity_period=dt.timedelta(days=5))      train_data_cfg =  Config.configure_data_node(id=\"train_data\", cacheable=True, validity_period=dt.timedelta(days=5))    task_preprocess_cfg = Config.configure_task(id=\"task_preprocess_data\",                                             function=preprocess,                                             input=[initial_data_cfg, country_cfg, date_cfg],                                             output=[final_data_cfg,train_data_cfg])    model_cfg = Config.configure_data_node(id=\"model\", cacheable=True, validity_period=dt.timedelta(days=5), scope=Scope.PIPELINE)    task_train_cfg = Config.configure_task(id=\"task_train\",                                        function=train_arima,                                        input=train_data_cfg,                                        output=model_cfg)     predictions_cfg = Config.configure_data_node(id=\"predictions\", scope=Scope.PIPELINE)    task_forecast_cfg = Config.configure_task(id=\"task_forecast\",                                        function=forecast,                                        input=model_cfg,                                        output=predictions_cfg)    result_cfg = Config.configure_data_node(id=\"result\", scope=Scope.PIPELINE)    task_result_cfg = Config.configure_task(id=\"task_result\",                                        function=result,                                        input=[final_data_cfg, predictions_cfg, date_cfg],                                        output=result_cfg)    pipeline_preprocessing_cfg = Config.configure_pipeline(id=\"pipeline_preprocessing\",                                                         task_configs=[task_preprocess_cfg])    pipeline_arima_cfg = Config.configure_pipeline(id=\"ARIMA\",                                                 task_configs=[task_train_cfg,                                                               task_forecast_cfg,                                                               task_result_cfg])    task_train_cfg = Config.configure_task(id=\"task_train_linear_regression\",                                        function=train_linear_regression,                                        input=train_data_cfg,                                        output=model_cfg)    task_forecast_cfg = Config.configure_task(id=\"task_forecast_linear_regression\",                                        function=forecast_linear_regression,                                        input=[model_cfg, date_cfg],                                        output=predictions_cfg)    pipeline_linear_regression_cfg = Config.configure_pipeline(id=\"LinearRegression\",                                                 task_configs=[task_train_cfg,                                                               task_forecast_cfg,                                                               task_result_cfg])    scenario_cfg = Config.configure_scenario(id='scenario', pipeline_configs=[pipeline_preprocessing_cfg,                                                                            pipeline_arima_cfg,                                                                            pipeline_linear_regression_cfg])"}
{"text": "import pandas as pd  from pmdarima import auto_arima  from sklearn.linear_model import LinearRegression  import datetime as dt  import numpy as np      def add_features(data):      dates = pd.to_datetime(data[\"Date\"])      data[\"Months\"] = dates.dt.month      data[\"Days\"] = dates.dt.isocalendar().day      data[\"Week\"] = dates.dt.isocalendar().week      data[\"Day of week\"] = dates.dt.dayofweek      return data    def create_train_data(final_data, date):      bool_index = pd.to_datetime(final_data['Date']) <= date      train_data = final_data[bool_index]      return train_data    def preprocess(initial_data, country, date):      data = initial_data.groupby([\"Country/Region\",'Date'])\\                         .sum()\\                         .dropna()\\                         .reset_index()        final_data = data.loc[data['Country/Region']==country].reset_index(drop=True)      final_data = final_data[['Date','Deaths']]      final_data = add_features(final_data)            train_data = create_train_data(final_data, date)      return final_data, train_data      def train_arima(train_data):      model = auto_arima(train_data['Deaths'],                         start_p=1, start_q=1,                         max_p=5, max_q=5,                         start_P=0, seasonal=False,                         d=1, D=1, trace=True,                         error_action='ignore',                           suppress_warnings=True)      model.fit(train_data['Deaths'])      return model      def forecast(model):      predictions = model.predict(n_periods=60)      return np.array(predictions)      def result(final_data, predictions, date):      dates = pd.to_datetime([date + dt.timedelta(days=i)                              for i in range(len(predictions))])      final_data['Date'] = pd.to_datetime(final_data['Date'])      predictions = pd.concat([pd.Series(dates, name=\"Date\"),                               pd.Series(predictions, name=\"Predictions\")], axis=1)      return final_data.merge(predictions, on=\"Date\", how=\"outer\")      def train_linear_regression(train_data):          y = train_data['Deaths']      X = train_data.drop(['Deaths','Date'], axis=1)            model = LinearRegression()      model.fit(X,y)      return model    def forecast_linear_regression(model, date):      dates = pd.to_datetime([date + dt.timedelta(days=i)                              for i in range(60)])      X = add_features(pd.DataFrame({\"Date\":dates}))      X.drop('Date', axis=1, inplace=True)      predictions = model.predict(X)      return predictions"}
{"text": "import pandas as pd    path_to_data = \"data/covid-19-all.csv\"  data = pd.read_csv(path_to_data, low_memory=False)"}
{"text": "from taipy.gui import Markdown  import numpy as np    import json    from data.data import data      type_selector = ['Absolute', 'Relative']  selected_type = type_selector[0]      def initialize_world(data):      data_world = data.groupby([\"Country/Region\",                                      'Date'])\\                              .sum()\\                              .reset_index()        with open(\"data/pop.json\",\"r\") as f:                  pop = json.load(f)            data_world['Population'] = [0]*len(data_world)      for i in range(len(data_world)):          data_world['Population'][i] = pop[data_world.loc[i, \"Country/Region\"]][1]      data_world = data_world.dropna()\\                              .reset_index()      data_world['Deaths/100k'] = data_world.loc[:,'Deaths']/data_world.loc[:,'Population']*100000            data_world_pie_absolute = data_world.groupby([\"Country/Region\"])\\                                          .max()\\                                          .sort_values(by='Deaths', ascending=False)[:20]\\                                          .reset_index()                                        data_world_pie_relative = data_world.groupby([\"Country/Region\"])\\                                          .max()\\                                          .sort_values(by='Deaths/100k', ascending=False)[:20]\\                                          .reset_index()\\                                          .drop(columns=['Deaths'])            country_absolute = data_world_pie_absolute['Country/Region'].unique().tolist()      country_relative = data_world_pie_relative.loc[:,'Country/Region'].unique().tolist()                           data_world_evolution_absolute = data_world[data_world['Country/Region'].str.contains('|'.join(country_absolute),regex=True)]      data_world_evolution_absolute = data_world_evolution_absolute.pivot(index='Date', columns='Country/Region', values='Deaths')\\                                       .reset_index()            data_world_evolution_relative = data_world[data_world['Country/Region'].str.contains('|'.join(country_relative),regex=True)]      data_world_evolution_relative = data_world_evolution_relative.pivot(index='Date', columns='Country/Region', values='Deaths/100k')\\                                       .reset_index()      return data_world, data_world_pie_absolute, data_world_pie_relative, data_world_evolution_absolute, data_world_evolution_relative        data_world,\\  data_world_pie_absolute, data_world_pie_relative,\\  data_world_evolution_absolute, data_world_evolution_relative = initialize_world(data)          data_world_evolution_absolute_properties = {\"x\":\"Date\"}  cols = [col for col in data_world_evolution_absolute.columns if col != \"Date\"]  for i in range(len(cols)):      data_world_evolution_absolute_properties[f'y[{i}]'] = cols[i]      data_world_evolution_relative_properties = {\"x\":\"Date\"}  cols = [col for col in data_world_evolution_relative.columns if col != \"Date\"]  for i in range(len(cols)):      data_world_evolution_relative_properties[f'y[{i}]'] = cols[i]              world_md = Markdown(\"\"\"  # **World**{: .color-primary} Statistics    <|{selected_type}|toggle|lov={type_selector}|>    <|layout|columns=1 1 1 1|gap=30px|  <|card m1|  #### **Deaths**{: .color-primary} <br/>  # <|{'{:,}'.format(int(np.sum(data_world_pie_absolute['Deaths']))).replace(',', ' ')}|text|raw|>  |>    <|card m1|  #### **Recovered**{: .color-primary} <br/>  # <|{'{:,}'.format(int(np.sum(data_world_pie_absolute['Recovered']))).replace(',', ' ')}|text|raw|>  |>    <|card m1|  #### **Confirmed**{: .color-primary} <br/>  # <|{'{:,}'.format(int(np.sum(data_world_pie_absolute['Confirmed']))).replace(',', ' ')}|text|raw|>  |>  |>    <br/>    <|part|render={selected_type=='Absolute'}|  <|layout|columns=1 2|gap=30px|  <|{data_world_pie_absolute}|chart|type=pie|label=Country/Region|x=Deaths|>    <|{data_world_evolution_absolute}|chart|properties={data_world_evolution_absolute_properties}|>  |>  |>    <|part|render={selected_type=='Relative'}|  <|layout|columns=1 2|gap=30px|  <|{data_world_pie_relative}|chart|type=pie|label=Country/Region|x=Deaths/100k|>    <|{data_world_evolution_relative}|chart|properties={data_world_evolution_relative_properties}|>  |>  |>  \"\"\")"}
{"text": "from taipy.gui import Markdown, invoke_long_callback  import taipy as tp   import pandas as pd    import datetime as dt    from config.config import scenario_cfg    scenario_selector = [(s.id, s.name) for s in tp.get_scenarios()]  selected_scenario = None  selected_date = dt.datetime(2020,10,1)    scenario_country = \"No selected scenario\"  scenario_date = \"No selected scenario\"  scenario_name = \"\"    result = pd.DataFrame({\"Date\":[dt.datetime(2020,1,1)],                         \"Deaths_x\":[0],\"Deaths_y\":[0],                         \"Predictions_x\":[0],\"Predictions_y\":[0]})    def create_new_scenario(state):      if state.scenario_name is not None or state.scenario_name == \"\":          scenario = tp.create_scenario(scenario_cfg, name=state.scenario_name)          state.scenario_selector += [(scenario.id, scenario.name)]          state.selected_scenario = scenario.id          actualize_graph(state)            def submit_heavy(scenario):      tp.submit(scenario)    def submit_status(state, status):      actualize_graph(state)    def submit_scenario(state):      # 1) get the selected scenario      # 2) write in country Data Node, the selected country      # 3) submit the scenario      # 4) actualize le graph avec actualize_graph      if state.selected_scenario is not None:          scenario = tp.get(state.selected_scenario)          scenario.country.write(state.selected_country)          scenario.date.write(state.selected_date.replace(tzinfo=None))          invoke_long_callback(state, submit_heavy, [scenario], submit_status)    def actualize_graph(state):      # 1) update the result dataframe      # 2) change selected_country with the predicted country of the scenario      if state.selected_scenario is not None:          scenario = tp.get(state.selected_scenario)          result_arima = scenario.pipelines['ARIMA'].result.read()          result_rd = scenario.pipelines['LinearRegression'].result.read()          if result_arima is not None and result_rd is not None:              state.result = result_rd.merge(result_arima, on=\"Date\", how=\"outer\").sort_values(by='Date')          else:              state.result = result          state.scenario_country = scenario.country.read()          state.scenario_date = scenario.date.read().strftime(\"%d %B %Y\")    predictions_md = Markdown(\"\"\"  # **Prediction**{: .color-primary} page      ## Scenario Creation      <|layout|columns=5 5 5 5|gap=30px|  **Scenario Name** <br/>  <|{scenario_name}|input|label=Name|> <br/> <|Create|button|on_action=create_new_scenario|>    **Prediction Date** <br/>  <|{selected_date}|date|label=Prediction date|>  <|Submit|button|on_action=submit_scenario|>    **Country** <br/>  <|{selected_country}|selector|lov={selector_country}|dropdown|on_change=on_change_country|label=Country|>  |>    ---------------------------------------    ## Result    <|layout|columns=2 3 3|gap=30px|  <|{selected_scenario}|selector|lov={scenario_selector}|on_change=actualize_graph|dropdown|value_by_id|label=Scenario|>     <|card m1|  #### Country of prediction :  <|{scenario_country}|>  |>    <|card m1|  #### Date of prediction : <|{scenario_date}|>  |>  |>  <br/>    <|{result}|chart|x=Date|y[1]=Deaths_x|type[1]=bar|y[2]=Predictions_x|y[3]=Predictions_y|>  \"\"\")"}
{"text": "  import numpy as np  from taipy.gui import Markdown    from data.data import data    marker_map = {\"color\":\"Deaths\", \"size\": \"Size\", \"showscale\":True, \"colorscale\":\"Viridis\"}  layout_map = {              \"dragmode\": \"zoom\",              \"mapbox\": { \"style\": \"open-street-map\", \"center\": { \"lat\": 38, \"lon\": -90 }, \"zoom\": 3}              }  options = {\"unselected\":{\"marker\":{\"opacity\":0.5}}}    def initialize_map(data):      data['Province/State'] = data['Province/State'].fillna(data[\"Country/Region\"])      data_province = data.groupby([\"Country/Region\",                                    'Province/State',                                    'Longitude',                                    'Latitude'])\\                           .max()                                   data_province_displayed = data_province[data_province['Deaths']>10].reset_index()        data_province_displayed['Size'] = np.sqrt(data_province_displayed.loc[:,'Deaths']/data_province_displayed.loc[:,'Deaths'].max())*80 + 3      data_province_displayed['Text'] = data_province_displayed.loc[:,'Deaths'].astype(str) + ' deaths </br> ' + data_province_displayed.loc[:,'Province/State']      return data_province_displayed      data_province_displayed = initialize_map(data)    map_md = Markdown(\"\"\"  # **Map**{: .color-primary} Statistics    <|{data_province_displayed}|chart|type=scattermapbox|lat=Latitude|lon=Longitude|marker={marker_map}|layout={layout_map}|text=Text|mode=markers|height=800px|options={options}|>  \"\"\") "}
{"text": "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}}}  country_md = \"<|{data_country_date}|chart|type=bar|x=Date|y[1]=Deaths|y[2]=Recovered|y[3]=Confirmed|layout={layout}|options={options}|>\"      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]]})      if state.selected_representation == 'Density':          convert_density(state)      country_md = Markdown(\"pages/country.md\") "}
{"text": "from taipy.gui import Gui, notify    text = \"\"  revealed = False    page = \"\"\"  <|{text if text else 'Write something in the input'}|>    <|{text}|input|on_change={lambda state: notify(state, 'i', s.text)}|>    <|part|render={len(text)>0}|  Part hidden and discovered after input  |>    -----    <|Push|button|on_action={lambda state: state.assign(\"revealed\", True)}|>    <|part|render={revealed}|  Part hidden and discovered after button  |>  \"\"\"    Gui(page).run()"}
{"text": "# Write an app that calls a function every 5 seconds"}
{"text": "from taipy.gui import Gui, Markdown, invoke_long_callback, notify  import numpy as np    status = 0  num_iterations = 10_000_000  pi_list = []    def pi_approx(num_iterations):      k, s = 3.0, 1.0      pi_list = []      for i in range(num_iterations):          s = s-((1/k) * (-1)**i)          k += 2          if (i+1)%(int(num_iterations/1_000)+1) == 0:              pi_list += [np.abs(4*s-np.pi)]        return pi_list          def heavy_status(state, status, pi_list):      notify(state, 'i', f\"Status parameter: {status}\")      if isinstance(status, bool):          if status:              notify(state, 'success', \"Finished\")              state.pi_list = pi_list          else:              notify(state, 'error', f\"An error was raised\")      else:          state.status += 1        def on_action(state):      invoke_long_callback(state,                           pi_approx, [int(state.num_iterations)],                           heavy_status, [],                           2000)              page = Markdown(\"\"\"  How many times was the status function called? <|{status}|>    ## Number of approximation    <|{num_iterations}|number|label=# of approximation|>    <|Approximate pie|button|on_action=on_action|>    ## Evolution of approximation  <|{pi_list}|chart|layout={layout}|>  \"\"\")    layout = {      \"yaxis\": {      \"type\": 'log',      \"autorange\": True      }    }    Gui(page).run()"}
{"text": "from taipy.gui import Gui, notify     text = \"\"    page_1 = \"\"\"  # Page 1  <|{text}|>  \"\"\"    page_2 = \"\"\"  # Page 2  <|Raise error|button|on_action=raise_error|>  \"\"\"    hidden_page_3 = \"\"\"  # Hidden Page  \"\"\"    def raise_error(state):      raise(ValueError(\"This is an error\"))      def on_init(state):      print(\"When a new client connects, this function is called\")      state.text = \"Hello, world!\"    def on_change(state, var_name, var_value):      notify(state, 'i', f'{var_name} changed')    def on_navigate(state, page_name: str):       if page_name == \"hidden_page_3\":          return \"page_1\"      notify(state, 'i', f'{page_name} navigated')      return page_name    def on_exception(state, function_name: str, ex: Exception):      err = f\"A problem occured in {function_name}\"      print(err)      notify(state, 'e', err)      pages = {           \"/\":\"<|navbar|>\",           \"page_1\": page_1,           \"page_2\": page_2,            \"hidden_page_3\": hidden_page_3}    Gui(pages=pages).run(port=5003)   "}
{"text": "from taipy.gui import Gui    selected = []    a = [1, 2]  b = [2, 3]    selector_lov = [a, b]    page = \"\"\"  <|{selected}|selector|lov={selector_lov}|adapter={lambda s: s.name}|>  \"\"\"    gui = Gui(page)  gui.run()"}
{"text": "from taipy.gui import Gui  from math import cos, exp    value = 10    page = \"\"\"  Markdown  # Taipy *Demo*    Value: <|{value}|text|>    <|{value}|slider|on_change=on_slider|>    <|{data}|chart|>  \"\"\"    def on_slider(state):      state.data = compute_data(state.value)    def compute_data(decay:int)->list:      return [cos(i/6) * exp(-i*decay/600) for i in range(100)]    data = compute_data(value)    Gui(page).run(use_reloader=True, port=5002)"}
{"text": "from taipy.gui import Gui  from math import cos, exp    value = 10    page = \"\"\"  Markdown  # Taipy *Demo*  \"\"\"    Gui(page).run(use_reloader=True, port=5002)"}
{"text": "# Write an app that create simple charts by poviding inputs and diplay them"}
{"text": "from taipy.gui import Gui     title = 1    md = \"\"\"  <|{title}|number|on_change=change_partial|>    <|part|partial={p}|>  \"\"\"    def change_partial(state):      title_int = int(state.title)      new_html = f'<h{title_int}>test{title_int}</h{title_int}>'      print(new_html)      state.p.update_content(state, new_html)    gui = Gui(md)  p = gui.add_partial(\"<h1>test</h1>\")  gui.run(port=5001)"}
{"text": "import yfinance as yf  from taipy.gui import Gui  from taipy.gui.data.decimator import MinMaxDecimator, RDP, LTTB      df_AAPL = yf.Ticker(\"AAPL\").history(interval=\"1d\", period = \"100Y\")  df_AAPL[\"DATE\"] = df_AAPL.index.astype(int).astype(float)    n_out = 500  decimator_instance = MinMaxDecimator(n_out=n_out)    decimate_data_count = len(df_AAPL)    page = \"\"\"  # Decimator    From a data length of <|{len(df_AAPL)}|> to <|{n_out}|>    ## Without decimator    <|{df_AAPL}|chart|x=DATE|y=Open|>    ## With decimator    <|{df_AAPL}|chart|x=DATE|y=Open|decimator=decimator_instance|>  \"\"\"    gui = Gui(page)  gui.run(port=5025) "}
{"text": "from taipy import Config  import taipy as tp    def read_text(path: str) -> str:      with open(path, 'r') as text_reader:          data = text_reader.read()      return data      def write_text(data: str, path: str) -> None:      with open(path, 'w') as text_writer:          text_writer.write(data)      historical_data_cfg = Config.configure_generic_data_node(      id=\"historical_data\",      read_fct=read_text,      write_fct=write_text,      read_fct_args=[\"../data.txt\"],      write_fct_args=[\"../data.txt\"])      scenario_cfg = Config.configure_scenario(id=\"my_scenario\", additional_data_node_configs=[historical_data_cfg])    scenario = tp.create_scenario(scenario_cfg) "}
{"text": "import taipy as tp  from config.config_toml import scenario_cfg    if __name__==\"__main__\":      tp.Core().run()      scenario_1 = tp.create_scenario(scenario_cfg)      scenario_2 = tp.create_scenario(scenario_cfg)      scenario_1.submit()      scenario_2.submit()        scenario_1 = tp.create_scenario(scenario_cfg)      scenario_1.submit(wait=True)      scenario_1.submit(wait=True, timeout=5) "}
{"text": "import taipy as tp    from config.config import scenario_cfg    if __name__==\"__main__\":      tp.Core().run()      scenario_1 = tp.create_scenario(scenario_cfg)      scenario_2 = tp.create_scenario(scenario_cfg)      scenario_1.submit()      scenario_2.submit()        scenario_1 = tp.create_scenario(scenario_cfg)      scenario_1.submit(wait=True)      scenario_1.submit(wait=True, timeout=5) "}
{"text": "from taipy import Config  from algos.algos import *    Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)    # Configuration of Data Nodes  input_cfg = Config.configure_data_node(\"input\", default_data=21)  intermediate_cfg = Config.configure_data_node(\"intermediate\", default_data=21)  output_cfg = Config.configure_data_node(\"output\")    # Configuration of tasks  first_task_cfg = Config.configure_task(\"double\",                                         double,                                         input_cfg,                                         intermediate_cfg)    second_task_cfg = Config.configure_task(\"add\",                                          add,                                          intermediate_cfg,                                          output_cfg)    # Configuration of the pipeline and scenario  scenario_cfg = Config.configure_scenario(id=\"my_scenario\",                                                      task_configs=[first_task_cfg,                                                                    second_task_cfg])    Config.export(\"config_07.toml\")"}
{"text": "from taipy import Config   from algos.algos import *    Config.load('config/config_07.toml')  Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)  scenario_cfg = Config.scenarios['my_scenario']   "}
{"text": "import time      # Normal function used by Taipy  def double(nb):      return nb * 2    def add(nb):      print(\"Wait 5 seconds in add function\")      time.sleep(5)      return nb + 10"}
{"text": "import taipy as tp    from taipy.gui import Markdown    from config.config import *    scenario = None  df_metrics = None  data_node = None      pages = {'/':'<|navbar|> <|toggle|theme|> <br/>',           'Scenario': Markdown('pages/scenario.md'),           'Data-Node': Markdown('pages/data_node.md')}      if __name__ == \"__main__\":      tp.Core().run()      tp.Gui(pages=pages).run(port=4999)"}
{"text": "import taipy as tp    import datetime as dt    from config.config import *      def create_and_run_scenario(date: dt.datetime):      scenario = tp.create_scenario(config=scenario_cfg,                                    name=f\"scenario_{date.date()}\",                                    creation_date=date)      scenario.day.write(date)      tp.submit(scenario)      return scenario    if __name__ == \"__main__\":      tp.Core().run()                my_first_scenario = create_and_run_scenario(dt.datetime(2021, 1, 25))            predictions = my_first_scenario.predictions.read()      print(\"Predictions\\n\", predictions)        [s for s in tp.get_scenarios()]      [d for d in tp.get_data_nodes()]        "}
{"text": "from taipy import Config, Scope, Frequency    from taipy.core import Scenario    import datetime as dt    from algos.algos import clean_data, predict, evaluate      ## Input Data Nodes  initial_dataset_cfg = Config.configure_data_node(id=\"initial_dataset\",                                                   storage_type=\"csv\",                                                   path=\"data/dataset.csv\",                                                   scope=Scope.GLOBAL)    # We assume the current day is the 26th of July 2021.  # This day can be changed to simulate multiple executions of scenarios on different days  day_cfg = Config.configure_data_node(id=\"day\", default_data=dt.datetime(2021, 7, 26))    ## Remaining Data Node  cleaned_dataset_cfg = Config.configure_data_node(id=\"cleaned_dataset\",                                                   storage_type=\"parquet\",                                                   scope=Scope.GLOBAL)  predictions_cfg = Config.configure_data_node(id=\"predictions\")    # Task config objects  clean_data_task_cfg = Config.configure_task(id=\"clean_data\",                                              function=clean_data,                                              input=initial_dataset_cfg,                                              output=cleaned_dataset_cfg,                                              skippable=True)    predict_task_cfg = Config.configure_task(id=\"predict\",                                                   function=predict,                                                   input=[cleaned_dataset_cfg, day_cfg],                                                   output=predictions_cfg)    evaluation_cfg = Config.configure_data_node(id=\"evaluation\")  evaluate_task_cfg = Config.configure_task(id=\"evaluate\",                                              function=evaluate,                                              input=[predictions_cfg, cleaned_dataset_cfg, day_cfg],                                              output=evaluation_cfg)    #   # Configure our scenario config.  scenario_cfg = Config.configure_scenario(id=\"scenario\", task_configs=[clean_data_task_cfg, predict_task_cfg,evaluate_task_cfg], frequency=Frequency.MONTHLY)    Config.export('config/config.toml')"}
{"text": "import datetime as dt  import pandas as pd      def clean_data(initial_dataset: pd.DataFrame):      print(\"     Cleaning data\")      initial_dataset['Date'] = pd.to_datetime(initial_dataset['Date'])      cleaned_dataset = initial_dataset[['Date', 'Value']]      return cleaned_dataset      def predict(cleaned_dataset: pd.DataFrame, day: dt.datetime):      print(\"     Predicting\")      train_dataset = cleaned_dataset[cleaned_dataset['Date'] < pd.Timestamp(day.date())]      predictions = train_dataset['Value'][-30:].reset_index(drop=True)      return pd.DataFrame({\"Prediction\":predictions})      def evaluate(predictions, cleaned_dataset, day):      print(\"     Evaluating\")      expected = cleaned_dataset.loc[cleaned_dataset['Date'] >= pd.Timestamp(day.date()), 'Value'][:30].reset_index(drop=True)      mae = ((predictions['Prediction'] - expected) ** 2).mean()      return int(mae) "}
{"text": "from taipy.gui import Gui, notify  import datetime as dt  import yfinance as yf    def get_stock_data(ticker):      now = dt.date.today()      past = now - dt.timedelta(days=365*2)      return yf.download(ticker, past, now).reset_index()    def update_ticker(state):      # state.data =       ...    ticker = 'AAPL'  data = get_stock_data(ticker)    historical = \"\"\"  \"\"\"    Gui(historical).run()"}
{"text": "from taipy.gui import Gui, notify  import datetime as dt  import yfinance as yf    def get_stock_data(ticker):      now = dt.date.today()      past = now - dt.timedelta(days=365*2)      return yf.download(ticker, past, now).reset_index()    def update_ticker(state):      state.data = get_stock_data(state.ticker)      notify(state, \"success\", \"Ticker updated!\")    ticker = 'AAPL'  data = get_stock_data(ticker)    historical = \"\"\"  #### Stock Price **Analysis**{: .color-primary}  <|{ticker}|toggle|lov=MSFT;GOOG;AAPL|on_change=update_ticker|>    Mean Volume: <|{int(data['Volume'].mean())}|>    <|{data}|chart|x=Date|y=Volume|>  \"\"\"    Gui(historical).run()"}
{"text": "from taipy.gui import Gui  import taipy as tp    from pages.data_viz import historical  from pages.predictions_sol import predictions, scenario    ticker = 'AAPL'    pages = {\"/\":\"<|navbar|>\",           \"Historical\":historical,           \"Prediction\":predictions}    tp.Core().run()  Gui(pages=pages).run(port=5001)"}
{"text": "from datetime import timedelta  import yfinance as yf  from prophet import Prophet    def get_data(ticker, date):      past = date - timedelta(days=365*7)      return yf.download(ticker, past, date).reset_index()    def predict(preprocessed_dataset):      df_train = preprocessed_dataset[['Date', 'Close']]      df_train = df_train.rename(columns={\"Date\": \"ds\", \"Close\": \"y\"})  # This is the format that Prophet accepts        m = Prophet()      m.fit(df_train)      future = m.make_future_dataframe(periods=365)      predictions = m.predict(future)[['ds', 'yhat']].rename(columns={'ds': 'Date', 'yhat': 'Predictions'})[-365:]      return predictions.reset_index()   "}
{"text": "import taipy as tp   from taipy.gui import notify, Markdown  import datetime as dt    tp.Config.load(\"config/config.toml\")    ticker = 'AAPL'  scenario = None  data_node = None  jobs = []  default_data = {\"Date\":[0], \"Predictions\":[0]}    def on_submission_status_change(state, submittable, details):      submission_status = details.get('submission_status')        if submission_status == 'COMPLETED':          print(f\"{submittable.name} has completed.\")          notify(state, 'success', 'Completed!')          state.refresh('scenario')        elif submission_status == 'FAILED':          print(f\"{submittable.name} has failed.\")          notify(state, 'error', 'Completed!')    predictions = Markdown(\"\"\"  Put a scenario selector                            ### **Daily**{: .color-primary} Predictions <|{scenario.ticker.read() if scenario else ticker}|toggle|lov=MSFT;GOOG;AAPL|active={scenario}|on_change=save|>    Put a scenario viewer                           <|{show_preditions(scenario)}|chart|x=Date|y=Predictions|>    <|1 5|layout|  Put a Data Node selector                           Put a Data Node  |>                           Put a job selector  \"\"\")    def show_preditions(scenario):      if scenario and scenario.predictions.read() is not None:          print(scenario)          return scenario.predictions.read()      else:          return default_data    def save(state, var_name, var_value):      state.scenario.ticker.write(var_value)      state.scenario.date.write(dt.date.today())      notify(state, \"success\", 'Parameters saved: ready for submission!')      state.scenario.predictions.write(None)      state.scenario = state.scenario"}
{"text": "import taipy as tp   from taipy.gui import notify, Markdown  import datetime as dt    tp.Config.load(\"config/config.toml\")    ticker = 'AAPL'  scenario = None  data_node = None  jobs = []  default_data = {\"Date\":[0], \"Predictions\":[0]}    def on_submission_status_change(state, submittable, details):      submission_status = details.get('submission_status')        if submission_status == 'COMPLETED':          print(f\"{submittable.name} has completed.\")          notify(state, 'success', 'Completed!')          state.refresh('scenario')        elif submission_status == 'FAILED':          print(f\"{submittable.name} has failed.\")          notify(state, 'error', 'Completed!')    predictions = Markdown(\"\"\"  <|{scenario}|scenario_selector|>     ### **Daily**{: .color-primary} Predictions <|{scenario.ticker.read() if scenario else ticker}|toggle|lov=MSFT;GOOG;AAPL|active={scenario}|on_change=save|>    <|{scenario}|scenario|on_submission_change=on_submission_status_change|>     <|{show_preditions(scenario)}|chart|x=Date|y=Predictions|>    <|1 5|layout|  <|{data_node}|data_node_selector|>    <|{data_node}|data_node|>  |>                           <|{jobs}|job_selector|>  \"\"\")    def show_preditions(scenario):      if scenario and scenario.predictions.read() is not None:          print(scenario)          return scenario.predictions.read()      else:          return default_data    def save(state, var_name, var_value):      state.scenario.ticker.write(var_value)      state.scenario.date.write(dt.date.today())      notify(state, \"success\", 'Parameters saved: ready for submission!')      state.scenario.predictions.write(None)      state.scenario = state.scenario"}
{"text": "from taipy.gui import notify, Markdown  import datetime as dt  import yfinance as yf    def get_stock_data(ticker):      now = dt.date.today()      past = now - dt.timedelta(days=365*2)      return yf.download(ticker, past, now).reset_index()    def update_ticker(state):      state.data = get_stock_data(state.ticker)      notify(state, \"success\", \"Ticker updated!\")    ticker = 'AAPL'  data = get_stock_data(ticker)    historical = Markdown(\"\"\"  ## Stock Price **Analysis**{: .color-primary} <|{ticker}|toggle|lov=MSFT;GOOG;AAPL|on_change=update_ticker|>    <|{data}|chart|x=Date|y=Volume|>  \"\"\")"}
{"text": "from taipy import Gui    import pandas as pd  import requests    API_URL = \"https://api-inference.huggingface.co/models/bigcode/starcoder\"  headers = {\"Authorization\": \"Bearer [ENTER-YOUR-API-KEY-HERE]\"}    DATA_PATH = \"data.csv\"    df = pd.read_csv(DATA_PATH, sep=\";\")  data = pd.DataFrame(      {          \"Date\": pd.to_datetime(              [                  \"2020-01-01\",                  \"2020-01-02\",                  \"2020-01-03\",                  \"2020-01-04\",                  \"2020-01-05\",                  \"2020-01-06\",                  \"2020-01-07\",              ]          ),          \"Sales\": [100, 250, 500, 400, 450, 600, 650],          \"Revenue\": [150, 200, 600, 800, 850, 900, 950],          \"Energy\": [\"Oil\", \"Coal\", \"Gas\", \"Nuclear\", \"Hydro\", \"Solar\", \"Wind\"],          \"Usage\": [0.33, 0.27, 0.21, 0.06, 0.05, 0.05, 0.03],      }  )  context = \"\"  for instruction, code in zip(df[\"instruction\"], df[\"code\"]):      context += f\"{instruction}\\n{code}\\n\"      def query(payload: dict) -> dict:      \"\"\"      Queries StarCoder API        Args:          payload: Payload for StarCoder API        Returns:          dict: StarCoder API response      \"\"\"      response = requests.post(API_URL, headers=headers, json=payload, timeout=20)      return response.json()      def prompt(input_instruction: str) -> str:      \"\"\"      Prompts StarCoder to generate Taipy GUI code        Args:          instuction (str): Instruction for StarCoder        Returns:          str: Taipy GUI code      \"\"\"      current_prompt = f\"{context}\\n{input_instruction}\\n\"      output = \"\"      final_result = \"\"        # Re-query until the output contains the closing tag      timeout = 0      while \">\" not in output and timeout < 10:          output = query(              {                  \"inputs\": current_prompt + output,                  \"parameters\": {                      \"return_full_text\": False,                  },              }          )[0][\"generated_text\"]          timeout += 1          final_result += output        output_code = f\"\"\"<{final_result.split(\"<\")[1].split(\">\")[0]}>\"\"\"      return output_code      def on_enter_press(state) -> None:      \"\"\"      Prompt StarCoder to generate Taipy GUI code when user presses enter        Args:          state (State): Taipy GUI state      \"\"\"      state.result = prompt(state.instruction)      state.p.update_content(state, state.result)      print(state.result)      instruction = \"\"  result = \"\"      page = \"\"\"  # Taipy**Copilot**{: .color-primary}    Enter your instruction here:  <|{instruction}|input|on_action=on_enter_press|class_name=fullwidth|>    <|Data|expandable|  <|{data[:5]}|table|width=100%|show_all=True|>  |>    <|part|partial={p}|>  \"\"\"    gui = Gui(page)  p = gui.add_partial(\"\"\"<|{data}|chart|mode=lines|x=Date|y=Sales|>\"\"\")  gui.run() "}
{"text": "from taipy.core.config import Config, Frequency, Status  import taipy as tp  import datetime as dt  import time      # Normal function used by Taipy  def double(nb):      return nb * 2    def add(nb):      print(\"Wait 10 seconds in add function\")      time.sleep(10)      return nb + 10      # Configuration of Data Nodes  input_cfg = Config.configure_data_node(\"input\", default_data=21)  intermediate_cfg = Config.configure_data_node(\"intermediate\")  output_cfg = Config.configure_data_node(\"output\")      # Configuration of tasks  first_task_cfg = Config.configure_task(\"double\",                                      double,                                      input_cfg,                                      intermediate_cfg)    second_task_cfg = Config.configure_task(\"add\",                                      add,                                      intermediate_cfg,                                      output_cfg)      def callback_scenario_state(scenario, job):      \"\"\"All the scenarios are subscribed to the callback_scenario_state function. It means whenever a job is done, it is called.      Depending on the job and the status, it will update the message stored in a json that is then displayed on the GUI.        Args:          scenario (Scenario): the scenario of the job changed          job (_type_): the job that has its status changed      \"\"\"      print(scenario.name)      if job.status == tp.core.Status.COMPLETED:          for data_node in job.task.output.values():              print(data_node.read())    # Configuration of scenario  scenario_cfg = Config.configure_scenario_from_tasks(id=\"my_scenario\",                                                      task_configs=[first_task_cfg,                                                                    second_task_cfg],                                                      name=\"my_scenario\")      Config.export(\"config_09.toml\")    if __name__==\"__main__\":      tp.Core().run()      scenario_1 = tp.create_scenario(scenario_cfg)      scenario_1.subscribe(callback_scenario_state)        scenario_1.submit(wait=True)            tp.Rest().run()     "}
{"text": "from taipy.core.config import Config, Scope, Frequency  import taipy as tp  import datetime as dt  import pandas as pd      def filter_by_month(df, month):      df['Date'] = pd.to_datetime(df['Date'])       df = df[df['Date'].dt.month == month]      return df    def count_values(df):      return len(df)      Config.load('config_06.toml')    # my_scenario is the id of the scenario configured  scenario_cfg = Config.scenarios['my_scenario']    if __name__ == '__main__':      tp.Core().run()        scenario_1 = tp.create_scenario(scenario_cfg,                                      creation_date=dt.datetime(2022,10,7),                                      name=\"Scenario 2022/10/7\")      scenario_2 = tp.create_scenario(scenario_cfg,                                  creation_date=dt.datetime(2022,10,5),                                  name=\"Scenario 2022/10/5\")      scenario_3 = tp.create_scenario(scenario_cfg,                                      creation_date=dt.datetime(2021,9,1),                                      name=\"Scenario 2022/9/1\")          # scenario 1 and 2 belongs to the same cycle      scenario_1.month.write(10)        scenario_1.submit()        # first task has already been executed by scenario 1      # because scenario 2 shares the same data node for this task      scenario_2.submit()        # every task has already been executed so everything will be skipped      scenario_2.submit()        # scenario 3 has no connection to the other scenarios so everything will be executed      scenario_3.month.write(9)      scenario_3.submit()        # changing an input data node will make the task be reexecuted      print(\"Scenario 3: change in historical data\")      scenario_3.historical_data.write(pd.read_csv('time_series_2.csv'))      scenario_3.submit()   "}
{"text": "from taipy.core.config import Config, Frequency  import taipy as tp      # Normal function used by Taipy  def double(nb):      return nb * 2    def add(nb):      return nb + 10      # Configuration of Data Nodes  input_cfg = Config.configure_data_node(\"input\", default_data=21)  intermediate_cfg = Config.configure_data_node(\"intermediate\")  output_cfg = Config.configure_data_node(\"output\")    # Configuration of tasks  first_task_cfg = Config.configure_task(\"double\",                                      double,                                      input_cfg,                                      intermediate_cfg)    second_task_cfg = Config.configure_task(\"add\",                                      add,                                      intermediate_cfg,                                      output_cfg)        def compare_function(*data_node_results):      # example of function      compare_result = {}      current_res_i = 0      for current_res in data_node_results:          compare_result[current_res_i] = {}          next_res_i = 0          for next_res in data_node_results:              print(f\"comparing result {current_res_i} with result {next_res_i}\")              compare_result[current_res_i][next_res_i] = next_res - current_res              next_res_i += 1          current_res_i += 1      return compare_result      scenario_cfg = Config.configure_scenario_from_tasks(id=\"multiply_scenario\",                                                      name=\"my_scenario\",                                                      task_configs=[first_task_cfg, second_task_cfg],                                                      comparators={output_cfg.id: compare_function})    Config.export(\"config_08.toml\")    if __name__==\"__main__\":      tp.Core().run()        scenario_1 = tp.create_scenario(scenario_cfg)      scenario_2 = tp.create_scenario(scenario_cfg)        scenario_1.input.write(10)      scenario_2.input.write(8)        scenario_1.submit()      scenario_2.submit()            print(tp.compare_scenarios(scenario_1, scenario_2))        tp.Rest().run() "}
{"text": "from taipy.core.config import Config  import taipy as tp  import datetime as dt  import pandas as pd  import time    # Normal function used by Taipy  def double(nb):      return nb * 2    def add(nb):      print(\"Wait 10 seconds in add function\")      time.sleep(10)      return nb + 10      Config.load('config_07.toml')  Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)      if __name__==\"__main__\":      scenario_cfg = Config.scenarios['my_scenario']      tp.Core().run()      scenario_1 = tp.create_scenario(scenario_cfg)      scenario_2 = tp.create_scenario(scenario_cfg)      scenario_1.submit()      scenario_2.submit()        scenario_1 = tp.create_scenario(scenario_cfg)      scenario_1.submit(wait=True)      scenario_1.submit(wait=True, timeout=5) "}
{"text": "from taipy.core.config import Config  import taipy as tp  import datetime as dt  import pandas as pd      def filter_current(df):      current_month = dt.datetime.now().month      df['Date'] = pd.to_datetime(df['Date'])       df = df[df['Date'].dt.month == current_month]      return df    def count_values(df):      return len(df)      historical_data_cfg = Config.configure_csv_data_node(id=\"historical_data\",                                                       default_path=\"src/time_series.csv\")  month_values_cfg =  Config.configure_data_node(id=\"month_data\")  nb_of_values_cfg = Config.configure_data_node(id=\"nb_of_values\")      task_filter_cfg = Config.configure_task(id=\"filter_current\",                                                   function=filter_current,                                                   input=historical_data_cfg,                                                   output=month_values_cfg)    task_count_values_cfg = Config.configure_task(id=\"count_values\",                                                   function=count_values,                                                   input=month_values_cfg,                                                   output=nb_of_values_cfg)      scenario_cfg = Config.configure_scenario_from_tasks(id=\"my_scenario\",                                                      task_configs=[task_filter_cfg,                                                                    task_count_values_cfg])    Config.export('config_03.toml')    if __name__ == '__main__':      tp.Core().run()        scenario = tp.create_scenario(scenario_cfg, creation_date=dt.datetime(2022,10,7), name=\"Scenario 2022/10/7\")      scenario.submit()        print(\"Nb of values of scenario:\", scenario.nb_of_values.read())        data_node = None        tp.Gui(\"\"\"<|{scenario}|scenario_selector|>                <|{scenario}|scenario|>                <|{scenario}|scenario_dag|>                <|{data_node}|data_node_selector|>\"\"\").run()   "}
{"text": "from taipy.core.config import Config  import taipy as tp  import datetime as dt  import pandas as pd  import time    # Normal function used by Taipy  def double(nb):      return nb * 2    def add(nb):      print(\"Wait 10 seconds in add function\")      time.sleep(10)      return nb + 10    Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)    # Configuration of Data Nodes  input_cfg = Config.configure_data_node(\"input\", default_data=21)  intermediate_cfg = Config.configure_data_node(\"intermediate\", default_data=21)  output_cfg = Config.configure_data_node(\"output\")    # Configuration of tasks  first_task_cfg = Config.configure_task(\"double\",                                         double,                                         input_cfg,                                         intermediate_cfg)    second_task_cfg = Config.configure_task(\"add\",                                          add,                                          intermediate_cfg,                                          output_cfg)    # Configuration of the pipeline and scenario  scenario_cfg = Config.configure_scenario_from_tasks(id=\"my_scenario\",                                                      task_configs=[first_task_cfg,                                                                    second_task_cfg])    Config.export(\"config_07.toml\")    if __name__==\"__main__\":      tp.Core().run()      scenario_1 = tp.create_scenario(scenario_cfg)      scenario_2 = tp.create_scenario(scenario_cfg)      scenario_1.submit()      scenario_2.submit()        scenario_1 = tp.create_scenario(scenario_cfg)      scenario_1.submit(wait=True)      scenario_1.submit(wait=True, timeout=5) "}
{"text": "from taipy.core.config import Config, Frequency, Scope  import taipy as tp  import datetime as dt  import pandas as pd      def filter_by_month(df, month):      df['Date'] = pd.to_datetime(df['Date'])       df = df[df['Date'].dt.month == month]      return df    def count_values(df):      return len(df)    Config.load('config_05.toml')    if __name__ == '__main__':      # my_scenario is the id of the scenario configured      scenario_cfg = Config.scenarios['my_scenario']        tp.Core().run()        scenario_1 = tp.create_scenario(scenario_cfg,                                      creation_date=dt.datetime(2022,10,7),                                      name=\"Scenario 2022/10/7\")      scenario_2 = tp.create_scenario(scenario_cfg,                                  creation_date=dt.datetime(2022,10,5),                                  name=\"Scenario 2022/10/5\")      scenario_3 = tp.create_scenario(scenario_cfg,                                      creation_date=dt.datetime(2021,9,1),                                      name=\"Scenario 2021/9/1\")          scenario_1.month.write(10)      print(\"Scenario 1: month\", scenario_1.month.read())      print(\"Scenario 2: month\", scenario_2.month.read())        print(\"\\nScenario 1: submit\")      scenario_1.submit()      print(\"Value\", scenario_1.nb_of_values.read())          print(\"\\nScenario 2: first submit\")      scenario_2.submit()      print(\"Value\", scenario_2.nb_of_values.read())      print(\"Scenario 2: second submit\")      scenario_2.submit()      print(\"Value\", scenario_2.nb_of_values.read())          print(\"\\nScenario 3: submit\")      scenario_3.month.write(9)      scenario_3.submit()      print(\"Value\", scenario_3.nb_of_values.read())"}
{"text": "from taipy.core.config import Config, Scope, Frequency  import taipy as tp  import datetime as dt  import pandas as pd      def filter_by_month(df, month):      df['Date'] = pd.to_datetime(df['Date'])       df = df[df['Date'].dt.month == month]      return df    def count_values(df):      return len(df)      historical_data_cfg = Config.configure_csv_data_node(id=\"historical_data\",                                                   default_path=\"time_series.csv\",                                                   scope=Scope.GLOBAL)  month_cfg =  Config.configure_data_node(id=\"month\", scope=Scope.CYCLE)  month_values_cfg =  Config.configure_data_node(id=\"month_data\",                                                 scope=Scope.CYCLE)    nb_of_values_cfg = Config.configure_data_node(id=\"nb_of_values\")      task_filter_cfg = Config.configure_task(id=\"filter_by_month\",                                                   function=filter_by_month,                                                   input=[historical_data_cfg, month_cfg],                                                   output=month_values_cfg,                                                   skippable=True)    task_count_values_cfg = Config.configure_task(id=\"count_values\",                                                   function=count_values,                                                   input=month_values_cfg,                                                   output=nb_of_values_cfg,                                                   skippable=True)    scenario_cfg = Config.configure_scenario_from_tasks(id=\"my_scenario\",                                                      task_configs=[task_filter_cfg,                                                                    task_count_values_cfg],                                                      frequency=Frequency.MONTHLY)    Config.export('config_06.toml')    if __name__ == '__main__':      tp.Core().run()        scenario_1 = tp.create_scenario(scenario_cfg,                                      creation_date=dt.datetime(2022,10,7),                                      name=\"Scenario 2022/10/7\")      scenario_2 = tp.create_scenario(scenario_cfg,                                  creation_date=dt.datetime(2022,10,5),                                  name=\"Scenario 2022/10/5\")      scenario_3 = tp.create_scenario(scenario_cfg,                                      creation_date=dt.datetime(2021,9,1),                                      name=\"Scenario 2022/9/1\")          # scenario 1 and 2 belongs to the same cycle      scenario_1.month.write(10)        scenario_1.submit()        # first task has already been executed by scenario 1      # because scenario 2 shares the same data node for this task      scenario_2.submit()        # every task has already been executed so everything will be skipped      scenario_2.submit()        # scenario 3 has no connection to the other scenarios so everything will be executed      scenario_3.month.write(9)      scenario_3.submit()        # changing an input data node will make the task be reexecuted      print(\"Scenario 3: change in historical data\")      scenario_3.historical_data.write(pd.read_csv('time_series_2.csv'))      scenario_3.submit()   "}
{"text": "from taipy.core.config import Config, Frequency  import taipy as tp  import datetime as dt  import pandas as pd      def filter_by_month(df, month):      df['Date'] = pd.to_datetime(df['Date'])       df = df[df['Date'].dt.month == month]      return df    def count_values(df):      return len(df)      Config.load('config_04.toml')    if __name__ == '__main__':      # my_scenario is the id of the scenario configured      scenario_cfg = Config.scenarios['my_scenario']        tp.Core().run()        scenario_1 = tp.create_scenario(scenario_cfg,                                      creation_date=dt.datetime(2022,10,7),                                      name=\"Scenario 2022/10/7\")      scenario_2 = tp.create_scenario(scenario_cfg,                                      creation_date=dt.datetime(2022,10,5),                                      name=\"Scenario 2022/10/5\")        scenario_1.month.write(10)      scenario_2.month.write(10)        print(\"Month Data Node of Scenario 1\", scenario_1.month.read())      print(\"Month Data Node of Scenario 2\", scenario_2.month.read())        scenario_1.submit()      scenario_2.submit()          print(\"Scenario 1 before\", scenario_1.is_primary)      print(\"Scenario 2 before\", scenario_2.is_primary)        tp.set_primary(scenario_2)        print(\"Scenario 1 after\", scenario_1.is_primary)      print(\"Scenario 2 after\", scenario_2.is_primary)          scenario_3 = tp.create_scenario(scenario_cfg,                                      creation_date=dt.datetime(2021,9,1),                                      name=\"Scenario 2022/9/1\")      scenario_3.month.write(9)      scenario_3.submit()        print(\"Is scenario 3 primary?\", scenario_3.is_primary)        data_node = None      scenario = None          tp.Gui(\"\"\"<|{scenario}|scenario_selector|>                <|{scenario}|scenario|>                <|{scenario}|scenario_dag|>                <|{data_node}|data_node_selector|>\"\"\").run() "}
{"text": "from taipy import Config  import taipy as tp      def double(nb):      return nb * 2    input_data_node_cfg = Config.configure_data_node(\"input\", default_data=21)  output_data_node_cfg = Config.configure_data_node(\"output\")    task_cfg = Config.configure_task(\"double\",                                   double,                                   input_data_node_cfg,                                   output_data_node_cfg)    scenario_cfg = Config.configure_scenario_from_tasks(id=\"my_scenario\",                                                      task_configs=[task_cfg])    Config.export('config_02.toml')    if __name__ == '__main__':      tp.Core().run()        scenario = tp.create_scenario(scenario_cfg, name=\"Scenario\")      tp.submit(scenario)      print(\"Output of First submit:\", scenario.output.read())        print(\"Before write\", scenario.input.read())      scenario.input.write(54)      print(\"After write\",scenario.input.read())          tp.submit(scenario)      print(\"Second submit\",scenario.output.read())        # Basic functions of Taipy Core       print([s.name for s in tp.get_scenarios()])      scenario = tp.get(scenario.id)      tp.delete(scenario.id)        scenario = None      data_node = None        tp.Gui(\"\"\"<|{scenario}|scenario_selector|>                <|{scenario}|scenario|>                <|{scenario}|scenario_dag|>                <|{data_node}|data_node_selector|>\"\"\").run() "}
{"text": "from taipy.core.config import Config, Frequency, Scope  import taipy as tp  import datetime as dt  import pandas as pd      def filter_by_month(df, month):      df['Date'] = pd.to_datetime(df['Date'])       df = df[df['Date'].dt.month == month]      return df    def count_values(df):      return len(df)      historical_data_cfg = Config.configure_csv_data_node(id=\"historical_data\",                                                   default_path=\"time_series.csv\",                                                   scope=Scope.GLOBAL)  month_cfg =  Config.configure_data_node(id=\"month\", scope=Scope.CYCLE)    month_values_cfg = Config.configure_data_node(id=\"month_data\",                                                 scope=Scope.CYCLE)  nb_of_values_cfg = Config.configure_data_node(id=\"nb_of_values\")      task_filter_cfg = Config.configure_task(id=\"filter_by_month\",                                                   function=filter_by_month,                                                   input=[historical_data_cfg,month_cfg],                                                   output=month_values_cfg)    task_count_values_cfg = Config.configure_task(id=\"count_values\",                                                   function=count_values,                                                   input=month_values_cfg,                                                   output=nb_of_values_cfg)        scenario_cfg = Config.configure_scenario_from_tasks(id=\"my_scenario\",                                                      task_configs=[task_filter_cfg,                                                                    task_count_values_cfg],                                                      frequency=Frequency.MONTHLY)    Config.export('config_05.toml')    if __name__ == '__main__':      tp.Core().run()        scenario_1 = tp.create_scenario(scenario_cfg,                                      creation_date=dt.datetime(2022,10,7),                                      name=\"Scenario 2022/10/7\")      scenario_2 = tp.create_scenario(scenario_cfg,                                  creation_date=dt.datetime(2022,10,5),                                  name=\"Scenario 2022/10/5\")      scenario_3 = tp.create_scenario(scenario_cfg,                                      creation_date=dt.datetime(2021,9,1),                                      name=\"Scenario 2021/9/1\")        scenario_1.month.write(10)      print(\"Scenario 1: month\", scenario_1.month.read())      print(\"Scenario 2: month\", scenario_2.month.read())        print(\"\\nScenario 1: submit\")      scenario_1.submit()      print(\"Value\", scenario_1.nb_of_values.read())        print(\"\\nScenario 2: first submit\")      scenario_2.submit()      print(\"Value\", scenario_2.nb_of_values.read())            print(\"Scenario 2: second submit\")      scenario_2.submit()      print(\"Value\", scenario_2.nb_of_values.read())        print(\"\\nScenario 3: submit\")      scenario_3.month.write(9)      scenario_3.submit()      print(\"Value\", scenario_3.nb_of_values.read()) "}
{"text": "from taipy import Config  import taipy as tp  import pandas as pd  import datetime as dt      data = pd.read_csv(\"https://raw.githubusercontent.com/Avaiga/taipy-getting-started-core/src/daily-min-temperatures.csv\")      # Normal function used by Taipy  def predict(historical_temperature: pd.DataFrame, date_to_forecast: str) -> float:      print(f\"Running baseline...\")      historical_temperature['Date'] = pd.to_datetime(historical_temperature['Date'])      historical_same_day = historical_temperature.loc[          (historical_temperature['Date'].dt.day == date_to_forecast.day) &          (historical_temperature['Date'].dt.month == date_to_forecast.month)      ]      return historical_same_day['Temp'].mean()    # Configuration of Data Nodes  historical_temperature_cfg = Config.configure_data_node(\"historical_temperature\")  date_to_forecast_cfg = Config.configure_data_node(\"date_to_forecast\")  predictions_cfg = Config.configure_data_node(\"predictions\")    # Configuration of tasks  predictions_cfg = Config.configure_task(\"predict\",                                          predict,                                          [historical_temperature_cfg, date_to_forecast_cfg],                                          predictions_cfg)    # Configuration of scenario  scenario_cfg = Config.configure_scenario_from_tasks(id=\"my_scenario\",                                                       task_configs=[predictions_cfg])    Config.export('config_01.toml')    if __name__ == '__main__':      # Run of the Core      tp.Core().run()        # Creation of the scenario and execution      scenario = tp.create_scenario(scenario_cfg)      scenario.historical_temperature.write(data)      scenario.date_to_forecast.write(dt.datetime.now())      tp.submit(scenario)        print(\"Value at the end of task\", scenario.predictions.read())        def save(state):          state.scenario.historical_temperature.write(data)          state.scenario.date_to_forecast.write(state.date)          tp.gui.notify(state, \"s\", \"Saved! Ready to submit\")        date = None      scenario_md = \"\"\"  <|{scenario}|scenario_selector|>  <|{date}|date|on_change=save|active={scenario}|>  <|{scenario}|scenario|>  <|{scenario}|scenario_dag|>    <|Refresh|button|on_action={lambda s: s.assign(\"scenario\", scenario)}|>  <|{scenario.predictions.read() if scenario else ''}|>  \"\"\"        tp.Gui(scenario_md).run()"}
{"text": "from taipy import Config  import taipy as tp  import pandas as pd  import datetime as dt      data = pd.read_csv(\"https://raw.githubusercontent.com/Avaiga/taipy-getting-started-core/src/daily-min-temperatures.csv\")      # Normal function used by Taipy  def predict(historical_temperature: pd.DataFrame, date_to_forecast: str) -> float:      print(f\"Running baseline...\")      historical_temperature['Date'] = pd.to_datetime(historical_temperature['Date'])      historical_same_day = historical_temperature.loc[          (historical_temperature['Date'].dt.day == date_to_forecast.day) &          (historical_temperature['Date'].dt.month == date_to_forecast.month)      ]      return historical_same_day['Temp'].mean()    Config.load('config_01.toml')    if __name__ == '__main__':      scenario_cfg = Config.scenarios['my_scenario']        # Run of the Core      tp.Core().run()        # Creation of the scenario and execution      scenario = tp.create_scenario(scenario_cfg)      scenario.historical_temperature.write(data)      scenario.date_to_forecast.write(dt.datetime.now())      tp.submit(scenario)        print(\"Value at the end of task\", scenario.predictions.read())        def save(state):          state.scenario.historical_temperature.write(data)          state.scenario.date_to_forecast.write(state.date)          tp.gui.notify(state, \"s\", \"Saved! Ready to submit\")        date = None      scenario_md = \"\"\"  <|{scenario}|scenario_selector|>  <|{date}|date|on_change=save|active={scenario}|>  <|{scenario}|scenario|>  <|{scenario}|scenario_dag|>    <|Refresh|button|on_action={lambda s: s.assign(\"scenario\", scenario)}|>  <|{scenario.predictions.read() if scenario else ''}|>  \"\"\"        tp.Gui(scenario_md).run()      Config.load('config_01.toml')    if __name__ == '__main__':          # my_scenario is the id of the scenario configured      scenario_cfg = Config.scenarios['my_scenario']          # Run of the Core      tp.Core().run()        # Creation of the scenario and execution      scenario = tp.create_scenario(scenario_cfg)      tp.submit(scenario)        print(\"Value at the end of task\", scenario.output.read())"}
{"text": "from taipy.core.config import Config, Frequency  import taipy as tp  import datetime as dt  import pandas as pd      def filter_by_month(df, month):      df['Date'] = pd.to_datetime(df['Date'])       df = df[df['Date'].dt.month == month]      return df    def count_values(df):      return len(df)      historical_data_cfg = Config.configure_csv_data_node(id=\"historical_data\",                                                       default_path=\"time_series.csv\")  month_cfg =  Config.configure_data_node(id=\"month\")  month_values_cfg =  Config.configure_data_node(id=\"month_data\")  nb_of_values_cfg = Config.configure_data_node(id=\"nb_of_values\")      task_filter_cfg = Config.configure_task(id=\"filter_by_month\",                                                   function=filter_by_month,                                                   input=[historical_data_cfg, month_cfg],                                                   output=month_values_cfg)    task_count_values_cfg = Config.configure_task(id=\"count_values\",                                                   function=count_values,                                                   input=month_values_cfg,                                                   output=nb_of_values_cfg)    scenario_cfg = Config.configure_scenario_from_tasks(id=\"my_scenario\",                                                      task_configs=[task_filter_cfg,                                                                    task_count_values_cfg],                                                      frequency=Frequency.MONTHLY)    Config.export('config_04.toml')    if __name__ == '__main__':      tp.Core().run()        scenario_1 = tp.create_scenario(scenario_cfg,                                      creation_date=dt.datetime(2022,10,7),                                      name=\"Scenario 2022/10/7\")      scenario_2 = tp.create_scenario(scenario_cfg,                                      creation_date=dt.datetime(2022,10,5),                                      name=\"Scenario 2022/10/5\")        scenario_1.month.write(10)      scenario_2.month.write(10)        print(\"Month Data Node of Scenario 1\", scenario_1.month.read())      print(\"Month Data Node of Scenario 2\", scenario_2.month.read())        scenario_1.submit()      scenario_2.submit()        print(\"Scenario 1 before\", scenario_1.is_primary)      print(\"Scenario 2 before\", scenario_2.is_primary)        tp.set_primary(scenario_2)        print(\"Scenario 1 after\", scenario_1.is_primary)      print(\"Scenario 2 after\", scenario_2.is_primary)        scenario_3 = tp.create_scenario(scenario_cfg,                                      creation_date=dt.datetime(2021,9,1),                                      name=\"Scenario 2022/9/1\")      scenario_3.month.write(9)      scenario_3.submit()        print(\"Is scenario 3 primary?\", scenario_3.is_primary)        scenario = None      data_node = None        tp.Gui(\"\"\"<|{scenario}|scenario_selector|>                <|{scenario}|scenario|>                <|{scenario}|scenario_dag|>                <|{data_node}|data_node_selector|>\"\"\").run() "}
{"text": "from taipy.core.config import Config, Scope, Frequency  import taipy as tp  import datetime as dt  import pandas as pd  import time      Config.load('config_09.toml')  Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)      def filter_by_month(df, month):      df['Date'] = pd.to_datetime(df['Date'])       df = df[df['Date'].dt.month == month]      return df    def count_values(df):      print(\"Wait 10 seconds\")      time.sleep(10)      return len(df)      def callback_scenario_state(scenario, job):      \"\"\"All the scenarios are subscribed to the callback_scenario_state function. It means whenever a job is done, it is called.      Depending on the job and the status, it will update the message stored in a json that is then displayed on the GUI.        Args:          scenario (Scenario): the scenario of the job changed          job (_type_): the job that has its status changed      \"\"\"      print(scenario.name)      if job.status.value == 7:          for data_node in job.task.output.values():              print(data_node.read())      if __name__==\"__main__\":      # my_scenario is the id of the scenario configured      scenario_cfg = Config.scenarios['my_scenario']        tp.Core().run()      scenario_1 = tp.create_scenario(scenario_cfg, creation_date=dt.datetime(2022,10,7), name=\"Scenario 2022/10/7\")      scenario_1.subscribe(callback_scenario_state)        scenario_1.submit(wait=True)      scenario_1.submit(wait=True, timeout=5)"}
{"text": "from taipy import Config  import taipy as tp      def double(nb):      return nb * 2    Config.load('config_02.toml')    if __name__ == '__main__':      # my_scenario is the id of the scenario configured      scenario_cfg = Config.scenarios['my_scenario']        scenario = tp.create_scenario(scenario_cfg, name=\"Scenario\")      tp.submit(scenario)      print(\"Output of First submit:\", scenario.output.read())        print(\"Before write\", scenario.input.read())      scenario.input.write(54)      print(\"After write\",scenario.input.read())          tp.submit(scenario)      print(\"Second submit\",scenario.output.read())        # Basic functions of Taipy Core       print([s.name for s in tp.get_scenarios()])      scenario = tp.get(scenario.id)      tp.delete(scenario.id)        scenario = None      data_node = None        tp.Gui(\"\"\"<|{scenario}|scenario_selector|>                <|{scenario}|scenario|>                <|{scenario}|scenario_dag|>                <|{data_node}|data_node_selector|>\"\"\").run()     "}
{"text": "from taipy.core.config import Config  import taipy as tp  import datetime as dt  import pandas as pd      def filter_current(df):      current_month = dt.datetime.now().month      df['Date'] = pd.to_datetime(df['Date'])       df = df[df['Date'].dt.month == current_month]      return df    def count_values(df):      return len(df)      Config.load('config_03.toml')    if __name__ == '__main__':      # my_scenario is the id of the scenario configured      scenario_cfg = Config.scenarios['my_scenario']        tp.Core().run()        scenario = tp.create_scenario(scenario_cfg, creation_date=dt.datetime(2022,10,7), name=\"Scenario 2022/10/7\")      scenario.submit()        print(\"Nb of values of scenario:\", scenario.nb_of_values.read())        data_node = None        tp.Gui(\"\"\"<|{scenario}|scenario_selector|>                <|{scenario}|scenario|>                <|{scenario}|scenario_dag|>                <|{data_node}|data_node_selector|>\"\"\").run()   "}
{"text": "from importlib import util, import_module  from pathlib import Path  import sys  import inspect  import os  import json    if len(sys.argv) < 3:    print(\"Packages should be passed as arguments after the name of the searched file.\", file=sys.stderr)    exit(1)  else:    errors = 0    file_name = sys.argv[1]    result = dict()    exit_code = 1    for package in sys.argv[2:]:      parts = package.split(\".\")      package_found = True      for idx in range(len(parts)):        if not util.find_spec(\".\".join(parts[0: idx+1])):          package_found = False          break      if not package_found:        print(f\"Package {package} not found.\", file=sys.stderr)        errors += 1      else:        module = import_module(package)        found = False        try:          module_file = inspect.getfile(module)          for root, dirs, files in os.walk(Path(module_file).parent.resolve()):            root_path = Path(root)            if file_name in files:              result[package] = str((root_path / file_name).resolve())              found = True        except Exception as e:          print(f\"Error accessing {package}: {e}.\", file=sys.stderr)          exit_code += 1        if not found:          print(f\"File {file_name} not found in Package {package}.\", file=sys.stderr)          errors += 1    if len(result):      json.dump(result, sys.stdout)    elif errors:      exit(exit_code) "}
{"text": "from taipy import Gui  import cv2    face_cascade = cv2.CascadeClassifier(\"haarcascade_frontalface_default.xml\")    number_of_faces_detected = 0  selected_file = None  image = None      def process_image(state):      img = cv2.imread(state.selected_file, cv2.IMREAD_UNCHANGED)      gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)      faces = face_cascade.detectMultiScale(gray)      state.number_of_faces_detected = len(faces)      # Draw a rectangle around faces      for (x, y, w, h) in faces:          cv2.rectangle(img, (x, y), (x + w, y + h), (255, 255, 0), 2)        state.image = cv2.imencode(\".jpg\", img)[1].tobytes()      content = \"\"\"  <|{selected_file}|file_selector|label=Upload File|on_action=process_image|extensions=.jpg,.gif,.png|drop_message=Drop Message|>    <|{image}|image|width=300px|height=300px|>    <|{number_of_faces_detected} face(s) detected|>  \"\"\"      if __name__ == \"__main__\":      Gui(page=content).run(dark_mode=False, port=8080) "}
{"text": "from setuptools import find_packages, setup    setup(      author=\"You Name\",      author_email=\"your@email.domain\",      python_requires=\">=3.8\",      classifiers=[          \"Intended Audience :: Developers\",          # \"License :: OSI Approved :: Apache Software License\",          \"Natural Language :: English\",          \"Programming Language :: Python :: 3\",          \"Programming Language :: Python :: 3.8\",          \"Programming Language :: Python :: 3.9\",          \"Programming Language :: Python :: 3.10\",      ],      # license=\"Apache License 2.0\",      install_requires=[\"taipy-gui>=2.0\"],      include_package_data=True,      name=\"guiext-library\",      description=\"My taipy-gui extension demo\",      long_description=\"This package contains a demonstration of using the Taipy GUI Extension API.\",      keywords=\"taipy\",      packages=find_packages(include=[\"demo_lib\", \"demo_lib.*\"]),      version=\"1.0.0\",      zip_safe=False  ) "}
{"text": "from taipy.gui import Gui  from library import Library    page = \"\"\"  # Extension library    <|library.element|>  \"\"\"  gui = Gui(page=page)  gui.add_library(Library())    if __name__ == \"__main__\":      # Run main app      gui.run() "}
{"text": "from pathlib import Path  from taipy.gui.extension import ElementLibrary, Element, ElementProperty, PropertyType      class Library(ElementLibrary):      elts = {          # Declare the elements of the library here, as key/value pairs of          # a dictionary.          # - The key is used as the element name.          # - The value must be an instance of taipy.gui.extension.Element          #          # Ex:          # \"element_name\": Element(          #    \"default_property_name\"          #    {          #      \"property_name\": ElementProperty(...)          #    },          #    react_component=\"ElementComponent\"          # ),      }        def get_name(self) -> str:          return \"library\"        def get_elements(self) -> dict:          return Library.elts        def get_scripts(self) -> list[str]:          # Only one JavaScript bundle for this library.          return [\"library/frontend/dist/library.js\"]        def get_resource(self, name: str) -> Path:          return super().get_resource(name) "}
{"text": "# Export the library class for easier access by developers using it  from .library import Library "}
{"text": "#Import modules  import taipy as tp  from taipy import Config, Scope, Gui  import pandas as pd  import numpy as np    #Back-End Code  #Filter function for best/worst colleges within 1 stat  def filtering_college(initial_dataset: pd.DataFrame, selected_stat, ):      completed_graph_dataset = initial_dataset[selected_stat]      completed_graph_data = completed_graph_dataset.nlargest(10, selected_stat, keep = \"all\")      return completed_graph_data    #Data Node Creation  initial_dataset_cfg = Config.configure_data_node(id=\"initial_dataset\",storage_type=\"csv\",path=\"College_Data.csv\",scope=Scope.GLOBAL)    selected_stat_cfg = Config.configure_data_node(id = \"selected_stat\", default_data = \"Name\", slope = Scope.GLOBAL)    completed_graph_data_cfg = Config.configure_data_node(id=\"completed_graph_data\", scope=Scope.GLOBAL)    #Task Creation  filtered_college_cfg = Config.configure_task(id = \"filtered_college\", function=filtering_college, input = [initial_dataset_cfg, selected_stat_cfg], output = [completed_graph_data_cfg])    #Pipeline Creation  pipeline_cfg = Config.configure_scenario(id=\"pipeline\",task_configs=[filtered_college_cfg])    #Scenario Creation  scenario_cfg = Config.configure_scenario(id = \"scenario\", pipeline_configs = [pipeline_cfg])  #scenario = tp.create_scenario(scenario_cfg)  #Core creation  if __name__ == \"__main__\":      tp.Core().run()  #Start of Front-End Code  #Callback Function  def modify_df(state):      scenario.selected_node.write(state.selected_stat)      tp.submit(scenario)      state.df = scenario.completed_graph_data_cfg.read()    list_stats = [\"Name\",\"Private\",\"Apps\",\"Accept\",\"Enroll\",\"Top10perc\",\"Top25perc\",\"F.Undergrad\",\"P.Undergrad\",\"Outstate\",\"Room.Board\",\"Books\",\"Personal\",\"PhD\",\"Terminal\",\"S.F.Ratio\",\"perc.alumni\",\"Expend\",\"Grad.Rate\"]  selected_stat = \"Top10perc\"  df = pd.DataFrame(columns = [\"Name\", selected_stat], copy = True)  #Variable Instantiation    #App Creation  college_stat_app = \"\"\"<|{selected_stat}|selector|lov={list_stats}|on_change=modify_df|dropdown|>  <|{df}|chart|x=Name|y=selected_stat|type=bar|title=College Stats|>\"\"\"        #Runs the app (finally)  print(selected_stat)  Gui(page = college_stat_app).run() "}
{"text": "import json      def add_line(source, line, step):        line = line.replace('Getting Started with Taipy GUI', 'Getting Started with Taipy GUI on Notebooks')      line = line.replace('(../src/', '(https://docs.taipy.io/en/latest/getting_started/src/')        if line.startswith('!['):          if step != 'index':              line = line.replace('(', '(https://github.com/Avaiga/taipy-getting-started-gui/blob/latest/' + step + '/')          else:              line = line.replace('(', '(https://github.com/Avaiga/taipy-getting-started-gui/blob/latest/')            # conversion of Markdown image to HTML          img_src = line.split('](')[1].split(')')[0]          width = line.split('](')[1].split(')')[1].split(' ')[1]            source.append('<div align=\"center\">\\n')          source.append(f' <img src={img_src} {width}>\\n')          source.append('</div>\\n')            elif step == 'step_00' and line.startswith('from taipy'):          source.append(\"from taipy.gui import Gui, Markdown\\n\")      elif 'Notebook' in line and 'step' in step:          pass      else:          source.append(line + '\\n')        return source      def detect_new_cell(notebook, source, cell, line, execution_count, force_creation=False):      if line.startswith('```python') or line.startswith('```') and cell == 'code' or force_creation:          source = source[:-1]            if cell == 'code':              notebook['cells'].append({                  \"cell_type\": \"code\",                  \"metadata\": {},                  \"outputs\": [],                  \"execution_count\": execution_count,                  \"source\": source              })              cell = 'markdown'              execution_count += 1          else:              notebook['cells'].append({                  \"cell_type\": \"markdown\",                  \"metadata\": {},                  \"source\": source              })              cell = 'code'            source = []        return cell, source, notebook, execution_count      def create_introduction(notebook, execution_count):      with open('index.md', 'r') as f:          text = f.read()        split_text = text.split('\\n')      source = []        for line in split_text:          if not line.startswith('``` console'):              add_line(source, line, 'index')          else:              break        notebook['cells'].append({          \"cell_type\": \"markdown\",          \"metadata\": {},          \"source\": source      })        notebook['cells'].append({          \"cell_type\": \"code\",          \"metadata\": {},          \"outputs\": [],          \"execution_count\": execution_count,          \"source\": ['# !pip install taipy\\n']      })        notebook['cells'].append({          \"cell_type\": \"markdown\",          \"metadata\": {},          \"source\": ['## Using Notebooks\\n',]      })        execution_count += 1      return notebook, execution_count      def create_steps(notebook, execution_count):      steps = ['step_0' + str(i) for i in range(1, 8)]      source = []        for step in steps:          if source != []:              cell, source, notebook, execution_count = detect_new_cell(notebook,                                                                        source,                                                                        cell,                                                                        line,                                                                        execution_count,                                                                        force_creation=True)            with open(step + '/ReadMe.md', 'r') as f:              text = f.read()            split_text = text.split('\\n')          cell = \"markdown\"            for_studio = 0            for line in split_text:              if cell == \"markdown\":                  line=line.replace(\"    \",\"\")              elif cell == \"code\" and (line[:4] == \"    \" or len(line)<=1) and for_studio == 2:                  line=line[4:]              else:                  for_studio = 0                            if '=== \"Taipy Studio' in line:                  for_studio = 1              if '=== \"Python configuration\"' in line:                  for_studio = 2                                if for_studio != 1:                  add_line(source, line, step)                  cell, source, notebook, execution_count = detect_new_cell(notebook, source, cell, line, execution_count)        return notebook, execution_count      if __name__ == '__main__':      notebook = {          \"cells\": [],          \"metadata\": {              \"language_info\": {                  \"codemirror_mode\": {                      \"name\": \"ipython\",                      \"version\": 3                  },                  \"file_extension\": \".py\",                  \"mimetype\": \"text/x-python\",                  \"name\": \"python\",                  \"nbconvert_exporter\": \"python\",                  \"pygments_lexer\": \"ipython3\"              },              \"orig_nbformat\": 4          },          \"nbformat\": 4,          \"nbformat_minor\": 2      }        execution_count = 0        notebook, execution_count = create_introduction(notebook, execution_count)      notebook, execution_count = create_steps(notebook, execution_count)        with open('getting_started.ipynb', 'w', encoding='utf-8') as f:          json.dump(notebook, f, indent=2) "}
{"text": "from taipy.gui import Gui, notify    text = \"Original text\"    # Definition of the page  page = \"\"\"  # Getting started with Taipy GUI    My text: <|{text}|>    <|{text}|input|>    <|Run local|button|on_action=on_button_action|>  \"\"\"    def on_button_action(state):      notify(state, 'info', f'The text is: {state.text}')      state.text = \"Button Pressed\"    def on_change(state, var_name, var_value):      if var_name == \"text\" and var_value == \"Reset\":          state.text = \"\"          return      Gui(page).run() "}
{"text": "from transformers import AutoTokenizer  from transformers import AutoModelForSequenceClassification  from scipy.special import softmax    import numpy as np  import pandas as pd   from taipy.gui import Gui, notify    text = \"Original text\"    page = \"\"\"  # Getting started with Taipy GUI    <|layout|columns=1 1|  <|  My text: <|{text}|>    Enter a word:  <|{text}|input|>  <|Analyze|button|on_action=local_callback|>  |>      <|Table|expandable|  <|{dataframe}|table|width=100%|number_format=%.2f|>  |>  |>    <|layout|columns=1 1 1|  ## Positive <|{np.mean(dataframe['Score Pos'])}|text|format=%.2f|raw|>    ## Neutral <|{np.mean(dataframe['Score Neu'])}|text|format=%.2f|raw|>    ## Negative <|{np.mean(dataframe['Score Neg'])}|text|format=%.2f|raw|>  |>    <|{dataframe}|chart|type=bar|x=Text|y[1]=Score Pos|y[2]=Score Neu|y[3]=Score Neg|y[4]=Overall|color[1]=green|color[2]=grey|color[3]=red|type[4]=line|>  \"\"\"    MODEL = f\"cardiffnlp/twitter-roberta-base-sentiment\"  tokenizer = AutoTokenizer.from_pretrained(MODEL)  model = AutoModelForSequenceClassification.from_pretrained(MODEL)    dataframe = pd.DataFrame({\"Text\":[''],                            \"Score Pos\":[0.33],                            \"Score Neu\":[0.33],                            \"Score Neg\":[0.33],                            \"Overall\":[0]})    dataframe2 = dataframe.copy()    def analyze_text(text):      # Run for Roberta Model      encoded_text = tokenizer(text, return_tensors='pt')      output = model(**encoded_text)      scores = output[0][0].detach().numpy()      scores = softmax(scores)            return {\"Text\":text[:50],              \"Score Pos\":scores[2],              \"Score Neu\":scores[1],              \"Score Neg\":scores[0],              \"Overall\":scores[2]-scores[0]}      def local_callback(state):      notify(state, 'Info', f'The text is: {state.text}', True)      temp = state.dataframe.copy()      scores = analyze_text(state.text)      temp.loc[len(temp)] = scores      state.dataframe = temp      state.text = \"\"      path = \"\"  treatment = 0    page_file = \"\"\"  <|{path}|file_selector|extensions=.txt|label=Upload .txt file|on_action=analyze_file|> <|{f'Downloading {treatment}%...'}|>    <br/>    <|Table|expandable|  <|{dataframe2}|table|width=100%|number_format=%.2f|>  |>    <br/>    <|{dataframe2}|chart|type=bar|x=Text|y[1]=Score Pos|y[2]=Score Neu|y[3]=Score Neg|y[4]=Overall|color[1]=green|color[2]=grey|color[3]=red|type[4]=line|height=600px|>    \"\"\"    def analyze_file(state):      state.dataframe2 = dataframe2      state.treatment = 0      with open(state.path,\"r\", encoding='utf-8') as f:          data = f.read()                    # split lines and eliminates duplicates          file_list = list(dict.fromkeys(data.replace('\\n', ' ').split(\".\")[:-1]))                  for i in range(len(file_list)):          text = file_list[i]          state.treatment = int((i+1)*100/len(file_list))          temp = state.dataframe2.copy()          scores = analyze_text(text)          temp.loc[len(temp)] = scores          state.dataframe2 = temp                state.path = None          pages = {\"/\":\"<|toggle|theme|>\\n<center>\\n<|navbar|>\\n</center>\",           \"line\":page,           \"text\":page_file}      Gui(pages=pages).run()"}
{"text": "from transformers import AutoTokenizer  from transformers import AutoModelForSequenceClassification  from scipy.special import softmax    import numpy as np  import pandas as pd   from taipy.gui import Gui, notify    text = \"Original text\"    page = \"\"\"  # Getting started with Taipy GUI    <|layout|columns=1 1|  <|  My text: <|{text}|>    Enter a word:  <|{text}|input|>  <|Analyze|button|on_action=local_callback|>  |>      <|Table|expandable|  <|{dataframe}|table|width=100%|number_format=%.2f|>  |>  |>    <|layout|columns=1 1 1|  ## Positive <|{float(np.mean(dataframe['Score Pos']))}|text|format=%.2f|raw|>%    ## Neutral <|{float(np.mean(dataframe['Score Neu']))}|text|format=%.2f|raw|>%    ## Negative <|{float(np.mean(dataframe['Score Neg']))}|text|format=%.2f|raw|>%  |>    <br/>    <|{dataframe}|chart|type=bar|x=Text|y[1]=Score Pos|y[2]=Score Neu|y[3]=Score Neg|y[4]=Overall|color[1]=green|color[2]=grey|color[3]=red|type[4]=line|>  \"\"\"    MODEL = f\"cardiffnlp/twitter-roberta-base-sentiment\"  tokenizer = AutoTokenizer.from_pretrained(MODEL)  model = AutoModelForSequenceClassification.from_pretrained(MODEL)    dataframe = pd.DataFrame({\"Text\":[''],                            \"Score Pos\":[0.33],                            \"Score Neu\":[0.33],                            \"Score Neg\":[0.33],                            \"Overall\":[0]})      def analyze_text(text):      # Run for Roberta Model      encoded_text = tokenizer(text, return_tensors='pt')      output = model(**encoded_text)      scores = output[0][0].detach().numpy()      scores = softmax(scores)            return {\"Text\":text,              \"Score Pos\":scores[2],              \"Score Neu\":scores[1],              \"Score Neg\":scores[0],              \"Overall\":scores[2]-scores[0]}      def local_callback(state):      notify(state, 'Info', f'The text is: {state.text}', True)      temp = state.dataframe.copy()      scores = analyze_text(state.text)      temp.loc[len(temp)] = scores      state.dataframe = temp      state.text = \"\"    Gui(page).run()"}
{"text": "from taipy.gui import Gui    text = \"Original text\"    page = \"\"\"  # Getting started with Taipy GUI    My text: <|{text}|>    <|{text}|input|>  \"\"\"    Gui(page).run()"}
{"text": "  from transformers import AutoTokenizer  from transformers import AutoModelForSequenceClassification  from scipy.special import softmax    import numpy as np  import pandas as pd   from taipy.gui import Gui, notify    text = \"Original text\"    MODEL = f\"cardiffnlp/twitter-roberta-base-sentiment\"  tokenizer = AutoTokenizer.from_pretrained(MODEL)  model = AutoModelForSequenceClassification.from_pretrained(MODEL)    dataframe = pd.DataFrame({\"Text\":[''],                            \"Score Pos\":[0.33],                            \"Score Neu\":[0.33],                            \"Score Neg\":[0.33],                            \"Overall\":[0]})    # Torch is, for now, only available for the Python version between 3.8 and 3.10.   # If you cannot install these packages, just return a dictionary of random numbers for the `analyze_text(text).`  def analyze_text(text):      # Run for Roberta Model      encoded_text = tokenizer(text, return_tensors='pt')      output = model(**encoded_text)      scores = output[0][0].detach().numpy()      scores = softmax(scores)            return {\"Text\":text,              \"Score Pos\":scores[2],              \"Score Neu\":scores[1],              \"Score Neg\":scores[0],              \"Overall\":scores[2]-scores[0]}      def local_callback(state):      notify(state, 'Info', f'The text is: {state.text}', True)      temp = state.dataframe.copy()      scores = analyze_text(state.text)      temp.loc[len(temp)] = scores      state.dataframe = temp      state.text = \"\"        page = \"\"\"  <|toggle|theme|>    # Getting started with Taipy GUI    My text: <|{text}|>    Enter a word:    <|{text}|input|>    <|Analyze|button|on_action=local_callback|>    ## Positive  <|{float(np.mean(dataframe['Score Pos']))}|text|format=%.2f|>%    ## Neutral  <|{float(np.mean(dataframe['Score Neu']))}|text|format=%.2f|>%    ## Negative  <|{float(np.mean(dataframe['Score Neg']))}|text|format=%.2f|>%    <|{dataframe}|table|number_format=%.2f|>    <|{dataframe}|chart|type=bar|x=Text|y[1]=Score Pos|y[2]=Score Neu|y[3]=Score Neg|y[4]=Overall|color[1]=green|color[2]=grey|color[3]=red|type[4]=line|>  \"\"\"    Gui(page).run()"}
{"text": "from taipy import Gui    Gui(page=\"# Getting started with *Taipy*\").run() "}
{"text": "import pandas as pd   from taipy.gui import Gui, notify      text = \"Original text\"    page = \"\"\"  <|toggle|theme|>    # Getting started with Taipy GUI    My text: <|{text}|>    <|{text}|input|>    <|Analyze|button|on_action=local_callback|>    <|{dataframe}|table|number_format=%.2f|>    <|{dataframe}|chart|type=bar|x=Text|y[1]=Score Pos|y[2]=Score Neu|y[3]=Score Neg|y[4]=Overall|color[1]=green|color[2]=grey|color[3]=red|type[4]=line|>  \"\"\"    dataframe = pd.DataFrame({\"Text\":['Test', 'Other', 'Love'],                            \"Score Pos\":[1, 1, 4],                            \"Score Neu\":[2, 3, 1],                            \"Score Neg\":[1, 2, 0],                            \"Overall\":[0, -1, 4]})      def local_callback(state):      notify(state, 'info', f'The text is: {state.text}')            temp = state.dataframe.copy()      temp.loc[len(temp)] = {\"Text\":state.text,                              \"Score Pos\":0,                              \"Score Neu\":0,                              \"Score Neg\":0,                              \"Overall\":0}      state.dataframe = temp      state.text = \"\"    Gui(page).run()"}
{"text": "  from taipy.gui import Gui, Markdown    input_pid = None  navigation = [(\"/add_product\", \"Add Prodcut\"), \"/\", \"Home\"]  page = \"\"\"  # Admin Panel  ## Add Product    def submit_button(state):      state.    <|{input_pid}|input|>  <|submit|button|on_action = submit_button>  \"\"\"      page1 = \"\"\"   ii   \"\"\"    Gui(page=page+page1).run(title=\"Go To Mall | Admin Panel\", port=4000) "}
{"text": "from taipy import Config  from taipy import Core, Gui  from taipy.gui import Markdown  import taipy as tp  from pages.home import home_md  from pages.temp import temp_page      def build_message(name: str):      return f\"Hello! {name}\"      input_name_data_node_cfg = Config.configure_data_node(id=\"input_name\")  message_data_node_cfg = Config.configure_data_node(id=\"message\")  build_msg_task_cfg = Config.configure_task(      \"buil_msg\", build_message, input_name_data_node_cfg, message_data_node_cfg)  scenario_cfg = Config.configure_scenario(      \"scenariod\", task_configs=[build_msg_task_cfg])    # making GUI    input_name = \"M ahi\"  message = None      def submit_scenario(state):      state.scenario.input_name.write(state.input_name)      state.scenario.submit()      state.message = scenario.message.read()      love = \"sazia\"  page = \"\"\"  Name: <|{input_name}|input|>  <|submit|button|on_action=submit_scenario|>  Message: <|{message}|text|>  Kima : <|All world are need to safe|text|>  \"\"\"      pages = {      \"/\": home_md,      \"temp\": temp_page,  }      if __name__ == \"__main__\":      Core().run()    #     mange scenarios and data      scenario = tp.create_scenario(scenario_cfg)    #     instance of run gui      Gui(pages=pages).run(title=\"Mahi Template\", port=5000,                           favicon=\"https://www.youtube.com/s/gaming/emoji/7ff574f2/emoji_u1f602.png\", ) "}
{"text": "from taipy.gui import Gui, Markdown  name = \"maho\"  ...  page = \"\"\"   ...   <|{dialog_is_visible}|dialog|   Enter a name:     <|{name}|input|>   |>   ...   \"\"\"  ...  pages = {    \"/\" : page,    'page1': Markdown(\"# My first page\"),    'page2': Markdown(\"# My second page\")  }        Gui(pages=pages).run(title=\"Mahi App\",port=5001 )"}
{"text": "from taipy.gui import Markdown, Gui      text = \"Welcome to home page\"  mahi_text = \"So how are you\"    home_md = Markdown(\"\"\"  # **Home**   <|{text}|> <br/>                     <|{mahi_text}|>    \"\"\") "}
{"text": "from taipy.gui import Gui, Markdown      def fahren_to_celcius(fahr):      return (fahr-32)*5/9      fahr = 100  celcious = fahren_to_celcius(fahr)    temp_page = Markdown(\"\"\"    # **Home**  Fahrenheit : <|{fahr}|>                    Converted Celcius : <|{celcious}|>    \"\"\") "}
{"text": "from taipy.gui import Gui, Markdown, notify    value = 0    single_page = Markdown(\"\"\"  # Taipy Application    Check the documentation [here](https://docs.taipy.io/en/latest/manuals/about/).    <|{value}|slider|on_change=on_slider|> <|Push|button|on_action=on_push|>    \"\"\")    def on_push(state):      ...    def on_slider(state):      if state.value == 100:          notify(state, \"success\", \"Taipy is running!\")    def on_change(state, var_name:str, var_value):      ...      if __name__ == \"__main__\":      gui = Gui(single_page)      gui.run() "}
{"text": "from taipy.gui import Gui  from taipy.config import Config     from pages.root.root import *  from pages.page_1.page_1 import page_1_md  from pages.page_2.page_2 import page_2_md    Config.load(\"config/config.toml\")    def on_change(state, var_name:str, var_value):      ...    pages = {\"/\":root_md,           \"page_1\":page_1_md,           \"page_2\":page_2_md}      if __name__ == \"__main__\":      gui = Gui(pages=pages)      gui.run() "}
{"text": "from taipy.config import Config"}
{"text": "import pandas as pd  import numpy as np    from sklearn.linear_model import LinearRegression    def clean_data(data):      ...      return data.dropna().drop_duplicates()    def predict(data):      model = LinearRegression()      model.fit(data[[\"x\"]], data[[\"y\"]])      data[\"y_pred\"] = model.predict(data[[\"x\"]])      return data    def evaluate(data):      ...      return np.random.rand()"}
{"text": "from taipy.gui import Markdown  import pandas as pd    scenario = None  results = None    def show_results(state):      state.results = state.scenario.predictions.read()    page_1_md = Markdown(\"pages/page_1/page_1.md\")"}
{"text": "from taipy.gui import Markdown    root_md = Markdown(\"pages/root/root.md\")"}
{"text": "from taipy.gui import Markdown    import pandas as pd    path = None  data = None    def drop_csv(state):      state.data = pd.read_csv(state.path)    page_2_md = Markdown(\"pages/page_2/page_2.md\")"}
{"text": "from taipy.gui import Gui, Markdown, notify    from pages.root.root import *  from pages.page_1.page_1 import page_1_md  from pages.page_2.page_2 import page_2_md      def on_change(state, var_name:str, var_value):      ...      pages = {\"/\":root_md,           \"page_1\":page_1_md,           \"page_2\":page_2_md}      if __name__ == \"__main__\":      gui = Gui(pages=pages)      gui.run() "}
{"text": "from taipy.gui import Markdown    page_1_md = Markdown(\"pages/page_1/page_1.md\")"}
{"text": "from taipy.gui import Markdown    root_md = Markdown(\"pages/root/root.md\")"}
{"text": "from taipy.gui import Markdown    page_2_md = Markdown(\"pages/page_2/page_2.md\")"}
{"text": "from taipy.gui import Gui  from pages import home  import os      gui = Gui(page=home.page).run(      title=\"Demo Logistic Regression\",      port=os.environ.get(\"PORT\", \"8000\"),  ) "}
{"text": "from config.nodes import (      node_initial_dataset,      node_prediction,      node_prediction_model,      node_X,      node_Y,  )  from models.data import make_X, make_Y  from models.predict import train, predict  from taipy import Config      task_make_X = Config.configure_task(      id=\"make_X\",      input=[node_initial_dataset],      output=node_X,      function=make_X,  )    task_make_Y = Config.configure_task(      id=\"make_Y\",      input=[node_initial_dataset],      output=node_Y,      function=make_Y,  )    task_train = Config.configure_task(      id=\"train\", input=[node_X, node_Y], output=node_prediction_model, function=train  )    task_predict = Config.configure_task(      id=\"predict\", input=[node_X, node_Y], output=node_prediction, function=predict  ) "}
{"text": ""}
{"text": "from taipy import Config      node_initial_dataset = Config.configure_data_node(id=\"initial_dataset\")    node_X = Config.configure_data_node(id=\"X\")    node_Y = Config.configure_data_node(id=\"Y\")    node_prediction_model = Config.configure_data_node(id=\"prediction_model\")    node_prediction = Config.configure_data_node(id=\"prediction\") "}
{"text": "from taipy import Config  from config.tasks import task_make_X, task_make_Y, task_train, task_predict    pipeline_train = Config.configure_pipeline(      id=\"train\", task_configs=[task_make_X, task_make_Y, task_train]  )    pipeline_predict = Config.configure_pipeline(id=\"predict\", task_configs=[task_predict]) "}
{"text": "from sklearn.linear_model import LogisticRegression      def train(X, Y):      X_train, Y_train = X[:50], Y[:50]      X_test, Y_test = X[50:], Y[50:]      # Using scikit-learn default      regression = LogisticRegression(random_state=0).fit(X_train, Y_train)      print(f\"intercept: {regression.intercept_} coefficients: {regression.coef_}\")      print(f\"train accuracy: {regression.score(X_train, Y_train)}\")      print(f\"test accuracy: {regression.score(X_test, Y_test)}\")      return regression      def predict(x, regression: LogisticRegression):      return regression.predict(x) "}
{"text": ""}
{"text": "import numpy as np    # Set seed for random number generator  rg = np.random.default_rng(seed=0)    # Create an array with 500 rows and 3 columns.  # This will serve as initial data node  initial_dataset = rg.normal(size=(500, 3))      def make_X(dataset):      # Remove the first column which can be considered as noise      X1 = np.delete(dataset, 0, axis=1)        # Now create two more columns correlated with X1      X2 = X1 + 0.1 * np.random.normal(size=(500, 2))      X = np.concatenate((X1, X2), axis=1)        return X      def make_Y(dataset):      P = 1 / (1 + np.e ** (-np.matmul(dataset, [1, 1, 1])))      Y = P > 0.5      return Y "}
{"text": "from taipy.gui import Markdown  import taipy as tp  from taipy.core.job.job import Job  from config.pipelines import pipeline_train  from models.data import initial_dataset      def job_status_changed(pipeline, job: Job):      print(job.status)      def training_button_clicked(state, id, action):      pipeline = tp.create_pipeline(pipeline_train)      # Set initial dataset:      pipeline.initial_dataset.write(initial_dataset)      tp.subscribe_pipeline(          pipeline=pipeline,          callback=job_status_changed,      )      tp.submit(pipeline)      page = Markdown(\"src/pages/home.md\") "}
{"text": ""}
{"text": "from taipy import Gui    page = \"\"\"  # Hello World \ud83c\udf0d with *Taipy*This is my first Taipy test app.  And it is running fine!  \"\"\"    Gui(page).run(use_reloader=True)  # use_reloader=True if you are in development   "}
{"text": "from taipy import Gui  from page.dashboard_fossil_fuels_consumption import *    if __name__ == \"__main__\":      Gui(page).run(          use_reloader=True,          title=\"Test\",          dark_mode=False,      )  # use_reloader=True if you are in development"}
{"text": "import pandas as pd  import taipy as tp    from data.data import dataset_fossil_fuels_gdp    country = \"Spain\"  region = \"Europe\"  lov_region = list(dataset_fossil_fuels_gdp.Entity.unique())      def load_dataset(_country):      \"\"\"Load dataset for a specific country.        Args:          _country (str): The name of the country.        Returns:          pandas.DataFrame: A DataFrame containing the fossil fuels GDP data for the specified country.      \"\"\"      dataset_fossil_fuels_gdp_cp = dataset_fossil_fuels_gdp.reset_index()        dataset_fossil_fuels_gdp_cp = dataset_fossil_fuels_gdp_cp[          dataset_fossil_fuels_gdp[\"Entity\"] == _country      ]      return dataset_fossil_fuels_gdp_cp      dataset_fossil_fuels_gdp_cp = load_dataset(country)      def on_change_country(state):      \"\"\"Update the dataset based on the selected country.        Args:          state (object): The \"state\" of the variables ran by the program (value changes through selectors)        Returns:          None      \"\"\"      print(\"country is:\", state.country)      _country = state.country      dataset_fossil_fuels_gdp_cp = load_dataset(_country)      state.dataset_fossil_fuels_gdp_cp = dataset_fossil_fuels_gdp_cp      layout = {\"yaxis\": {\"range\": [0, 100000]}, \"xaxis\": {\"range\": [1965, 2021]}}    page = \"\"\"  # Fossil Fuel consumption by per capita by country*    Data comes from <a href=\"https://ourworldindata.org/grapher/per-capita-fossil-energy-vs-gdp\" target=\"_blank\">Our World in Data</a>    <|{country}|selector|lov={lov_region}|on_change=on_change_country|dropdown|label=Country/Region|>        <|{dataset_fossil_fuels_gdp_cp}|chart|type=plot|x=Year|y=Fossil fuels per capita (kWh)|height=200%|layout={layout}|>    ## Fossil fuel per capita for <|{country}|>:  <|{dataset_fossil_fuels_gdp_cp}|table|height=400px|width=95%|>      \"\"\" "}
{"text": "import pandas as pd      dataset_fossil_fuels_gdp = pd.read_csv(\"data/per-capita-fossil-energy-vs-gdp.csv\")  country_codes = pd.read_csv(\"./data/country_codes.csv\")    dataset_fossil_fuels_gdp = dataset_fossil_fuels_gdp.merge(      country_codes[[\"alpha-3\", \"region\"]], how=\"left\", left_on=\"Code\", right_on=\"alpha-3\"  )    dataset_fossil_fuels_gdp = dataset_fossil_fuels_gdp[      ~dataset_fossil_fuels_gdp[\"Fossil fuels per capita (kWh)\"].isnull()  ].reset_index()    dataset_fossil_fuels_gdp[\"Fossil fuels per capita (kWh)\"] = (      dataset_fossil_fuels_gdp[\"Fossil fuels per capita (kWh)\"] * 1000  ) "}
{"text": "# This is a sample Python script.    # Press Maj+F10 to execute it or replace it with your code.  # Press Double Shift to search everywhere for classes, files, tool windows, actions, and settings.      def print_hi(name):      # Use a breakpoint in the code line below to debug your script.      print(f'Hi, {name}')  # Press Ctrl+F8 to toggle the breakpoint.      # Press the green button in the gutter to run the script.  if __name__ == '__main__':      print_hi('PyCharm')    # See PyCharm help at https://www.jetbrains.com/help/pycharm/ "}
{"text": "from taipy.gui import Gui, notify  from taipy import Config  import pandas as pd    tasks = pd.DataFrame({      \"Type\":[],      \"Name\":[],      \"Completed\":[]  })    tasks[\"Completed\"] = tasks[\"Completed\"].astype(\"bool\")    task_name=\"\"  task_type=\"\"    page = \"\"\"  # TODO Schedular    Enter Task: <|{task_name}|input|>    Type: <|{task_type}|selector|lov=Personal;Home;Work|dropdown|>    <|Add Task|button|on_action=on_task_add|>    <|{tasks}|table|filter|editable|editable[Type]=False|on_edit=on_task_edit|on_delete=on_task_delete|style=style_completed|>  \"\"\"    def style_completed(_1, _2, values):      if(values[\"Completed\"]):          return \"strikeout\"    def on_task_edit(state, var_name, payload):      if(var_name == \"tasks\"):          index = payload[\"index\"]          col = payload[\"col\"]          value = payload[\"user_value\"]            new_tasks = state.tasks.copy()          new_tasks.loc[index, col] = value          state.tasks = new_tasks          notify(state, \"I\", \"Task Updated.\")       def on_task_delete(state, var_name, payload):      if(var_name == \"tasks\"):          index = payload[\"index\"]          state.tasks = state.tasks.drop(index=index)          notify(state, \"E\", \"Task Deleted.\")        def on_task_add(state, var_name, payload):      if(state.task_name == \"\" or state.task_type == \"\"):          notify(state, \"E\", \"Task Name or Task Type Not Set.\")          return False      _task_type = state.task_type      _task_name = state.task_name      _isCompleted = False      new_data = pd.DataFrame([[_task_type, _task_name, _isCompleted]], columns=state.tasks.columns)      state.tasks = pd.concat([new_data, state.tasks], axis=0, ignore_index=True)      notify(state, \"S\", \"New Task Added Successfully.\")    Gui(page, css_file=\"todo.css\").run(use_reloader=True)"}
{"text": "#!/usr/bin/env python    \"\"\"The setup script.\"\"\"  import json  import os    from setuptools import find_namespace_packages, find_packages, setup    with open(\"README.md\") as readme_file:      readme = readme_file.read()    with open(f\"src{os.sep}taipy{os.sep}config{os.sep}version.json\") as version_file:      version = json.load(version_file)      version_string = f'{version.get(\"major\", 0)}.{version.get(\"minor\", 0)}.{version.get(\"patch\", 0)}'      if vext := version.get(\"ext\"):          version_string = f\"{version_string}.{vext}\"    requirements = [\"toml>=0.10,<0.11\", \"deepdiff>=6.2,<6.3\"]    test_requirements = [\"pytest>=3.8\"]    setup(      author=\"Avaiga\",      author_email=\"dev@taipy.io\",      python_requires=\">=3.8\",      classifiers=[          \"Intended Audience :: Developers\",          \"License :: OSI Approved :: Apache Software License\",          \"Natural Language :: English\",          \"Programming Language :: Python :: 3\",          \"Programming Language :: Python :: 3.8\",          \"Programming Language :: Python :: 3.9\",          \"Programming Language :: Python :: 3.10\",      ],      description=\"A Taipy package dedicated to easily configure a Taipy application.\",      install_requires=requirements,      long_description=readme,      long_description_content_type=\"text/markdown\",      include_package_data=True,      license=\"Apache License 2.0\",      keywords=\"taipy-config\",      name=\"taipy-config\",      package_dir={\"\": \"src\"},      packages=find_namespace_packages(where=\"src\")      + find_packages(include=[\"taipy\", \"taipy.config\", \"taipy.config.*\", \"taipy.logger\", \"taipy.logger.*\"]),      test_suite=\"tests\",      tests_require=test_requirements,      url=\"https://github.com/avaiga/taipy-config\",      version=version_string,      zip_safe=False,  ) "}
{"text": "import ast  import re  from pathlib import Path  from typing import List      def _get_function_delimiters(initial_line, lines):      begin = end = initial_line      while True:          if lines[begin - 1] == \"\\n\":              break          begin -= 1        if lines[end].endswith(\"(\\n\"):          while \":\\n\" not in lines[end]:              end += 1        if '\"\"\"' in lines[end + 1]:          while True:              if '\"\"\"\\n' in lines[end]:                  break              end += 1      return begin, end + 1      def _get_file_lines(filename: str) -> List[str]:      # Get file lines for later      with open(filename) as f:          return f.readlines()      def _get_file_ast(filename: str):      # Get raw text and build ast      _config = Path(filename)      _tree = _config.read_text()      return ast.parse(_tree)      def _build_base_config_pyi(filename, base_pyi):      lines = _get_file_lines(filename)      tree = _get_file_ast(filename)        class_lineno = [f.lineno for f in ast.walk(tree) if isinstance(f, ast.ClassDef) and f.name == \"Config\"]      begin_class, end_class = _get_function_delimiters(class_lineno[0] - 1, lines)        base_pyi += \"\".join(lines[begin_class:end_class])      functions = [f.lineno for f in ast.walk(tree) if isinstance(f, ast.FunctionDef) and not f.name.startswith(\"__\")]        for ln in functions:          begin_line, end_line = _get_function_delimiters(ln - 1, lines)          base_pyi += \"\".join(lines[begin_line:end_line])            base_pyi = __add_docstring(base_pyi, lines, end_line)          base_pyi += \"\\n\"        return base_pyi      def __add_docstring(base_pyi, lines, end_line):      if '\"\"\"' not in lines[end_line - 1]:          base_pyi += '\\t\\t\"\"\"\"\"\"\\n'.replace(\"\\t\", \"    \")      return base_pyi      def _build_entity_config_pyi(base_pyi, filename, entity_map):      lines = _get_file_lines(filename)      tree = _get_file_ast(filename)      functions = {}        for f in ast.walk(tree):          if isinstance(f, ast.FunctionDef):              if \"_configure\" in f.name and not f.name.startswith(\"__\"):                  functions[f.name] = f.lineno              elif \"_set_default\" in f.name and not f.name.startswith(\"__\"):                  functions[f.name] = f.lineno              elif \"_add\" in f.name and not f.name.startswith(\"__\"):                  functions[f.name] = f.lineno        for k, v in functions.items():          begin_line, end_line = _get_function_delimiters(v - 1, lines)          try:              func = \"\".join(lines[begin_line:end_line])              func = func if not k.startswith(\"_\") else func.replace(k, entity_map.get(k))              func = __add_docstring(func, lines, end_line) + \"\\n\"              base_pyi += func          except Exception:              print(f\"key={k}\")              raise        return base_pyi      def _generate_entity_and_property_maps(filename):      entities_map = {}      property_map = {}      entity_tree = _get_file_ast(filename)      functions = [          f for f in ast.walk(entity_tree) if isinstance(f, ast.Call) and getattr(f.func, \"id\", \"\") == \"_inject_section\"      ]        for f in functions:          entity = ast.unparse(f.args[0])          entities_map[entity] = {}          property_map[eval(ast.unparse(f.args[1]))] = entity          # Remove class name from function map          text = ast.unparse(f.args[-1]).replace(f\"{entity}.\", \"\")          matches = re.findall(r\"\\((.*?)\\)\", text)            for m in matches:              v, k = m.replace(\"'\", \"\").split(\",\")              entities_map[entity][k.strip()] = v      return entities_map, property_map      def _generate_acessors(base_pyi, property_map):      for property, cls in property_map.items():          return_template = f\"Dict[str, {cls}]\" if property != \"job_config\" else f\"{cls}\"          template = (\"\\t@_Classproperty\\n\" + f'\\tdef {property}(cls) -> {return_template}:\\n\\t\\t\"\"\"\"\"\"\\n').replace(              \"\\t\", \"    \"          )          base_pyi += template + \"\\n\"      return base_pyi      def _build_header(filename):      _file = Path(filename)      return _file.read_text() + \"\\n\\n\"      if __name__ == \"__main__\":      header_file = \"stubs/pyi_header.py\"      config_init = Path(\"taipy-core/src/taipy/core/config/__init__.py\")      base_config = \"src/taipy/config/config.py\"        dn_filename = \"taipy-core/src/taipy/core/config/data_node_config.py\"      job_filename = \"taipy-core/src/taipy/core/config/job_config.py\"      scenario_filename = \"taipy-core/src/taipy/core/config/scenario_config.py\"      task_filename = \"taipy-core/src/taipy/core/config/task_config.py\"      migration_filename = \"taipy-core/src/taipy/core/config/migration_config.py\"      core_filename = \"taipy-core/src/taipy/core/config/core_section.py\"        entities_map, property_map = _generate_entity_and_property_maps(config_init)      pyi = _build_header(header_file)      pyi = _build_base_config_pyi(base_config, pyi)      pyi = _generate_acessors(pyi, property_map)      pyi = _build_entity_config_pyi(pyi, scenario_filename, entities_map[\"ScenarioConfig\"])      pyi = _build_entity_config_pyi(pyi, dn_filename, entities_map[\"DataNodeConfig\"])      pyi = _build_entity_config_pyi(pyi, task_filename, entities_map[\"TaskConfig\"])      pyi = _build_entity_config_pyi(pyi, job_filename, entities_map[\"JobConfig\"])      pyi = _build_entity_config_pyi(pyi, migration_filename, entities_map[\"MigrationConfig\"])      pyi = _build_entity_config_pyi(pyi, core_filename, entities_map[\"CoreSection\"])        with open(\"src/taipy/config/config.pyi\", \"w\") as f:          f.writelines(pyi) "}
{"text": "import json  from typing import Any, Callable, Dict, List, Optional, Union  from datetime import timedelta    from taipy.core.config import DataNodeConfig, JobConfig, ScenarioConfig, TaskConfig, MigrationConfig, CoreSection    from .checker.issue_collector import IssueCollector  from .common._classproperty import _Classproperty  from .common._config_blocker import _ConfigBlocker  from .common.frequency import Frequency  from .common.scope import Scope  from .global_app.global_app_config import GlobalAppConfig  from .section import Section  from .unique_section import UniqueSection "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import os  import pathlib  from unittest import TestCase, mock    from src.taipy.logger._taipy_logger import _TaipyLogger      class TestTaipyLogger(TestCase):      def test_taipy_logger(self):          _TaipyLogger._get_logger().info(\"baz\")          _TaipyLogger._get_logger().debug(\"qux\")        def test_taipy_logger_configured_by_file(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"logger.conf\")          with mock.patch.dict(os.environ, {\"TAIPY_LOGGER_CONFIG_PATH\": path}):              _TaipyLogger._get_logger().info(\"baz\")              _TaipyLogger._get_logger().debug(\"qux\") "}
{"text": "import os    import pytest    from src.taipy.config.config import Config  from src.taipy.config.exceptions.exceptions import ConfigurationUpdateBlocked  from tests.config.utils.named_temporary_file import NamedTemporaryFile    config_from_filename = NamedTemporaryFile(      \"\"\"  [TAIPY]  custom_property_not_overwritten = true  custom_property_overwritten = 10  \"\"\"  )    config_from_environment = NamedTemporaryFile(      \"\"\"  [TAIPY]  custom_property_overwritten = 11  \"\"\"  )      def test_load_from_environment_overwrite_load_from_filename():      os.environ[Config._ENVIRONMENT_VARIABLE_NAME_WITH_CONFIG_PATH] = config_from_environment.filename      Config.load(config_from_filename.filename)        assert Config.global_config.custom_property_not_overwritten is True      assert Config.global_config.custom_property_overwritten == 11      os.environ.pop(Config._ENVIRONMENT_VARIABLE_NAME_WITH_CONFIG_PATH)      def test_block_load_from_environment_overwrite_load_from_filename():      Config.load(config_from_filename.filename)      assert Config.global_config.custom_property_not_overwritten is True      assert Config.global_config.custom_property_overwritten == 10        Config.block_update()        with pytest.raises(ConfigurationUpdateBlocked):          os.environ[Config._ENVIRONMENT_VARIABLE_NAME_WITH_CONFIG_PATH] = config_from_environment.filename          Config.load(config_from_filename.filename)        os.environ.pop(Config._ENVIRONMENT_VARIABLE_NAME_WITH_CONFIG_PATH)      assert Config.global_config.custom_property_not_overwritten is True      assert Config.global_config.custom_property_overwritten == 10  # The Config.load is failed to override "}
{"text": "import pytest    from src.taipy.config._config import _Config  from src.taipy.config._config_comparator._config_comparator import _ConfigComparator  from src.taipy.config._serializer._toml_serializer import _TomlSerializer  from src.taipy.config.checker.issue_collector import IssueCollector  from src.taipy.config.config import Config  from src.taipy.config.section import Section  from tests.config.utils.section_for_tests import SectionForTest  from tests.config.utils.unique_section_for_tests import UniqueSectionForTest      @pytest.fixture(scope=\"function\", autouse=True)  def reset():      reset_configuration_singleton()      register_test_sections()      def reset_configuration_singleton():      Config.unblock_update()      Config._default_config = _Config()._default_config()      Config._python_config = _Config()      Config._file_config = _Config()      Config._env_file_config = _Config()      Config._applied_config = _Config()      Config._collector = IssueCollector()      Config._serializer = _TomlSerializer()      Config._comparator = _ConfigComparator()      def register_test_sections():      Config._register_default(UniqueSectionForTest(\"default_attribute\"))      Config.configure_unique_section_for_tests = UniqueSectionForTest._configure      Config.unique_section_name = Config.unique_sections[UniqueSectionForTest.name]        Config._register_default(SectionForTest(Section._DEFAULT_KEY, \"default_attribute\", prop=\"default_prop\", prop_int=0))      Config.configure_section_for_tests = SectionForTest._configure      Config.section_name = Config.sections[SectionForTest.name] "}
{"text": "import os  from unittest import mock    import pytest    from src.taipy.config.exceptions.exceptions import InvalidConfigurationId  from tests.config.utils.section_for_tests import SectionForTest  from tests.config.utils.unique_section_for_tests import UniqueSectionForTest      class WrongUniqueSection(UniqueSectionForTest):      name = \"1wrong_id\"      class WrongSection(SectionForTest):      name = \"correct_name\"      def test_section_uses_valid_id():      with pytest.raises(InvalidConfigurationId):          WrongUniqueSection(attribute=\"foo\")      with pytest.raises(InvalidConfigurationId):          WrongSection(\"wrong id\", attribute=\"foo\")      with pytest.raises(InvalidConfigurationId):          WrongSection(\"1wrong_id\", attribute=\"foo\")      with pytest.raises(InvalidConfigurationId):          WrongSection(\"wrong_@id\", attribute=\"foo\")      def test_templated_properties_are_replaced():      with mock.patch.dict(os.environ, {\"foo\": \"bar\", \"baz\": \"1\"}):          u_sect = UniqueSectionForTest(attribute=\"attribute\", tpl_property=\"ENV[foo]\")          assert u_sect.tpl_property == \"bar\"            sect = SectionForTest(id=\"my_id\", attribute=\"attribute\", tpl_property=\"ENV[baz]:int\")          assert sect.tpl_property == 1 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from src.taipy.config.config import Config  from src.taipy.config.global_app.global_app_config import GlobalAppConfig  from src.taipy.config.section import Section  from tests.config.utils.section_for_tests import SectionForTest  from tests.config.utils.unique_section_for_tests import UniqueSectionForTest      def _test_default_global_app_config(global_config: GlobalAppConfig):      assert global_config is not None      assert not global_config.notification      assert len(global_config.properties) == 0      def test_default_configuration():      default_config = Config._default_config      assert default_config._unique_sections is not None      assert len(default_config._unique_sections) == 1      assert default_config._unique_sections[UniqueSectionForTest.name] is not None      assert default_config._unique_sections[UniqueSectionForTest.name].attribute == \"default_attribute\"      assert default_config._sections is not None      assert len(default_config._sections) == 1        _test_default_global_app_config(default_config._global_config)      _test_default_global_app_config(Config.global_config)      _test_default_global_app_config(GlobalAppConfig().default_config())      def test_register_default_configuration():      Config._register_default(SectionForTest(Section._DEFAULT_KEY, \"default_attribute\", prop1=\"prop1\"))        # Replace the first default section      Config._register_default(SectionForTest(Section._DEFAULT_KEY, \"default_attribute\", prop2=\"prop2\"))        default_section = Config.sections[SectionForTest.name][Section._DEFAULT_KEY]      assert len(default_section.properties) == 1      assert default_section.prop2 == \"prop2\"      assert default_section.prop1 is None "}
{"text": "import pytest    from src.taipy.config.config import Config  from src.taipy.config.exceptions.exceptions import LoadingError  from tests.config.utils.named_temporary_file import NamedTemporaryFile      def test_node_can_not_appear_twice():      config = NamedTemporaryFile(          \"\"\"  [unique_section_name]  attribute = \"my_attribute\"    [unique_section_name]  attribute = \"other_attribute\"      \"\"\"      )        with pytest.raises(LoadingError, match=\"Can not load configuration\"):          Config.load(config.filename)      def test_skip_configuration_outside_nodes():      config = NamedTemporaryFile(          \"\"\"  foo = \"bar\"      \"\"\"      )        Config.load(config.filename)      assert Config.global_config.foo is None "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from src.taipy.config._config import _Config  from src.taipy.config.checker._checker import _Checker      class TestDefaultConfigChecker:      def test_check_default_config(self):          config = _Config._default_config()          collector = _Checker._check(config)          assert len(collector._errors) == 0          assert len(collector._infos) == 0          assert len(collector._warnings) == 0 "}
{"text": "from src.taipy.config.checker.issue import Issue  from src.taipy.config.checker.issue_collector import IssueCollector      class TestIssueCollector:      def test_add_error(self):          collector = IssueCollector()          assert len(collector.errors) == 0          assert len(collector.warnings) == 0          assert len(collector.infos) == 0          assert len(collector.all) == 0          collector._add_error(\"field\", \"value\", \"message\", \"checker\")          assert len(collector.errors) == 1          assert len(collector.warnings) == 0          assert len(collector.infos) == 0          assert len(collector.all) == 1          assert collector.all[0] == Issue(IssueCollector._ERROR_LEVEL, \"field\", \"value\", \"message\", \"checker\")          collector._add_error(\"field\", \"value\", \"message\", \"checker\")          assert len(collector.errors) == 2          assert len(collector.warnings) == 0          assert len(collector.infos) == 0          assert len(collector.all) == 2          assert collector.all[0] == Issue(IssueCollector._ERROR_LEVEL, \"field\", \"value\", \"message\", \"checker\")          assert collector.all[1] == Issue(IssueCollector._ERROR_LEVEL, \"field\", \"value\", \"message\", \"checker\")        def test_add_warning(self):          collector = IssueCollector()          assert len(collector.errors) == 0          assert len(collector.warnings) == 0          assert len(collector.infos) == 0          assert len(collector.all) == 0          collector._add_warning(\"field\", \"value\", \"message\", \"checker\")          assert len(collector.errors) == 0          assert len(collector.warnings) == 1          assert len(collector.infos) == 0          assert len(collector.all) == 1          assert collector.all[0] == Issue(IssueCollector._WARNING_LEVEL, \"field\", \"value\", \"message\", \"checker\")          collector._add_warning(\"field\", \"value\", \"message\", \"checker\")          assert len(collector.errors) == 0          assert len(collector.warnings) == 2          assert len(collector.infos) == 0          assert len(collector.all) == 2          assert collector.all[0] == Issue(IssueCollector._WARNING_LEVEL, \"field\", \"value\", \"message\", \"checker\")          assert collector.all[1] == Issue(IssueCollector._WARNING_LEVEL, \"field\", \"value\", \"message\", \"checker\")        def test_add_info(self):          collector = IssueCollector()          assert len(collector.errors) == 0          assert len(collector.warnings) == 0          assert len(collector.infos) == 0          assert len(collector.all) == 0          collector._add_info(\"field\", \"value\", \"message\", \"checker\")          assert len(collector.errors) == 0          assert len(collector.warnings) == 0          assert len(collector.infos) == 1          assert len(collector.all) == 1          assert collector.all[0] == Issue(IssueCollector._INFO_LEVEL, \"field\", \"value\", \"message\", \"checker\")          collector._add_info(\"field\", \"value\", \"message\", \"checker\")          assert len(collector.errors) == 0          assert len(collector.warnings) == 0          assert len(collector.infos) == 2          assert len(collector.all) == 2          assert collector.all[0] == Issue(IssueCollector._INFO_LEVEL, \"field\", \"value\", \"message\", \"checker\")          assert collector.all[1] == Issue(IssueCollector._INFO_LEVEL, \"field\", \"value\", \"message\", \"checker\")        def test_all(self):          collector = IssueCollector()          collector._add_info(\"foo\", \"bar\", \"baz\", \"qux\")          assert collector.all[0] == Issue(IssueCollector._INFO_LEVEL, \"foo\", \"bar\", \"baz\", \"qux\")          collector._add_warning(\"foo2\", \"bar2\", \"baz2\", \"qux2\")          assert collector.all[0] == Issue(IssueCollector._WARNING_LEVEL, \"foo2\", \"bar2\", \"baz2\", \"qux2\")          assert collector.all[1] == Issue(IssueCollector._INFO_LEVEL, \"foo\", \"bar\", \"baz\", \"qux\")          collector._add_warning(\"foo3\", \"bar3\", \"baz3\", \"qux3\")          assert collector.all[0] == Issue(IssueCollector._WARNING_LEVEL, \"foo2\", \"bar2\", \"baz2\", \"qux2\")          assert collector.all[1] == Issue(IssueCollector._WARNING_LEVEL, \"foo3\", \"bar3\", \"baz3\", \"qux3\")          assert collector.all[2] == Issue(IssueCollector._INFO_LEVEL, \"foo\", \"bar\", \"baz\", \"qux\")          collector._add_info(\"field\", \"value\", \"message\", \"checker\")          collector._add_error(\"field\", \"value\", \"message\", \"checker\")          assert collector.all[0] == Issue(IssueCollector._ERROR_LEVEL, \"field\", \"value\", \"message\", \"checker\")          assert collector.all[1] == Issue(IssueCollector._WARNING_LEVEL, \"foo2\", \"bar2\", \"baz2\", \"qux2\")          assert collector.all[2] == Issue(IssueCollector._WARNING_LEVEL, \"foo3\", \"bar3\", \"baz3\", \"qux3\")          assert collector.all[3] == Issue(IssueCollector._INFO_LEVEL, \"foo\", \"bar\", \"baz\", \"qux\")          assert collector.all[4] == Issue(IssueCollector._INFO_LEVEL, \"field\", \"value\", \"message\", \"checker\") "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import os  from unittest import mock  from unittest.mock import MagicMock    from src.taipy.config import Config  from src.taipy.config.checker._checker import _Checker  from src.taipy.config.checker.issue_collector import IssueCollector  from tests.config.utils.checker_for_tests import CheckerForTest      def test_register_checker():      checker = CheckerForTest      checker._check = MagicMock()      _Checker.add_checker(checker)      Config.check()      checker._check.assert_called_once() "}
{"text": "import logging  from unittest import mock    from src.taipy.config._config import _Config  from src.taipy.config.checker._checkers._config_checker import _ConfigChecker  from src.taipy.config.checker.issue import Issue  from src.taipy.config.checker.issue_collector import IssueCollector      class MyCustomChecker(_ConfigChecker):      def _check(self) -> IssueCollector:          pass      def test__error():      with mock.patch.object(logging.Logger, \"error\"):          collector = IssueCollector()          assert len(collector.all) == 0          _ConfigChecker(_Config(), collector)._error(\"field\", 17, \"my message\")          assert len(collector.all) == 1          assert len(collector.errors) == 1          assert len(collector.warnings) == 0          assert len(collector.infos) == 0          assert collector.errors[0] == Issue(IssueCollector._ERROR_LEVEL, \"field\", 17, \"my message\", \"_ConfigChecker\")            MyCustomChecker(_Config(), collector)._error(\"foo\", \"bar\", \"baz\")          assert len(collector.all) == 2          assert len(collector.errors) == 2          assert len(collector.warnings) == 0          assert len(collector.infos) == 0          assert collector.errors[0] == Issue(IssueCollector._ERROR_LEVEL, \"field\", 17, \"my message\", \"_ConfigChecker\")          assert collector.errors[1] == Issue(IssueCollector._ERROR_LEVEL, \"foo\", \"bar\", \"baz\", \"MyCustomChecker\")      def test__warning():      collector = IssueCollector()      assert len(collector.all) == 0      _ConfigChecker(_Config(), collector)._warning(\"field\", 17, \"my message\")      assert len(collector.all) == 1      assert len(collector.warnings) == 1      assert len(collector.errors) == 0      assert len(collector.infos) == 0      assert collector.warnings[0] == Issue(IssueCollector._WARNING_LEVEL, \"field\", 17, \"my message\", \"_ConfigChecker\")        MyCustomChecker(_Config(), collector)._warning(\"foo\", \"bar\", \"baz\")      assert len(collector.all) == 2      assert len(collector.warnings) == 2      assert len(collector.errors) == 0      assert len(collector.infos) == 0      assert collector.warnings[0] == Issue(IssueCollector._WARNING_LEVEL, \"field\", 17, \"my message\", \"_ConfigChecker\")      assert collector.warnings[1] == Issue(IssueCollector._WARNING_LEVEL, \"foo\", \"bar\", \"baz\", \"MyCustomChecker\")      def test__info():      collector = IssueCollector()      assert len(collector.all) == 0      _ConfigChecker(_Config(), collector)._info(\"field\", 17, \"my message\")      assert len(collector.all) == 1      assert len(collector.infos) == 1      assert len(collector.errors) == 0      assert len(collector.warnings) == 0      assert collector.infos[0] == Issue(IssueCollector._INFO_LEVEL, \"field\", 17, \"my message\", \"_ConfigChecker\")        MyCustomChecker(_Config(), collector)._info(\"foo\", \"bar\", \"baz\")      assert len(collector.all) == 2      assert len(collector.infos) == 2      assert len(collector.errors) == 0      assert len(collector.warnings) == 0      assert collector.infos[0] == Issue(IssueCollector._INFO_LEVEL, \"field\", 17, \"my message\", \"_ConfigChecker\")      assert collector.infos[1] == Issue(IssueCollector._INFO_LEVEL, \"foo\", \"bar\", \"baz\", \"MyCustomChecker\") "}
{"text": "from src.taipy.config import IssueCollector  from src.taipy.config.checker._checkers._config_checker import _ConfigChecker      class CheckerForTest(_ConfigChecker):        def _check(self) -> IssueCollector:          return self._collector "}
{"text": "from copy import copy  from typing import Any, Dict, List, Optional    from src.taipy.config import Config, Section  from src.taipy.config._config import _Config  from src.taipy.config.common._config_blocker import _ConfigBlocker    from .section_for_tests import SectionForTest      class SectionOfSectionsListForTest(Section):        name = \"list_section_name\"      _MY_ATTRIBUTE_KEY = \"attribute\"      _SECTIONS_LIST_KEY = \"sections_list\"        def __init__(self, id: str, attribute: Any = None, sections_list: List = None, **properties):          self._attribute = attribute          self._sections_list = sections_list if sections_list else []          super().__init__(id, **properties)        def __copy__(self):          return SectionOfSectionsListForTest(              self.id, self._attribute, copy(self._sections_list), **copy(self._properties)          )        @property      def attribute(self):          return self._replace_templates(self._attribute)        @attribute.setter  # type: ignore      @_ConfigBlocker._check()      def attribute(self, val):          self._attribute = val        @property      def sections_list(self):          return list(self._sections_list)        @sections_list.setter  # type: ignore      @_ConfigBlocker._check()      def sections_list(self, val):          self._sections_list = val        def _clean(self):          self._attribute = None          self._sections_list = []          self._properties.clear()        def _to_dict(self):          as_dict = {}          if self._attribute is not None:              as_dict[self._MY_ATTRIBUTE_KEY] = self._attribute          if self._sections_list:              as_dict[self._SECTIONS_LIST_KEY] = self._sections_list          as_dict.update(self._properties)          return as_dict        @classmethod      def _from_dict(cls, as_dict: Dict[str, Any], id: str, config: Optional[_Config] = None):          as_dict.pop(cls._ID_KEY, id)          attribute = as_dict.pop(cls._MY_ATTRIBUTE_KEY, None)          section_configs = config._sections.get(SectionForTest.name, None) or []  # type: ignore          sections_list = []          if inputs_as_str := as_dict.pop(cls._SECTIONS_LIST_KEY, None):              for section_id in inputs_as_str:                  if section_id in section_configs:                      sections_list.append(section_configs[section_id])                  else:                      sections_list.append(section_id)          return SectionOfSectionsListForTest(id=id, attribute=attribute, sections_list=sections_list, **as_dict)        def _update(self, as_dict: Dict[str, Any], default_section=None):          self._attribute = as_dict.pop(self._MY_ATTRIBUTE_KEY, self._attribute)          if self._attribute is None and default_section:              self._attribute = default_section._attribute          self._sections_list = as_dict.pop(self._SECTIONS_LIST_KEY, self._sections_list)          if self._sections_list is None and default_section:              self._sections_list = default_section._sections_list          self._properties.update(as_dict)          if default_section:              self._properties = {**default_section.properties, **self._properties}        @staticmethod      def _configure(id: str, attribute: str, sections_list: List = None, **properties):          section = SectionOfSectionsListForTest(id, attribute, sections_list, **properties)          Config._register(section)          return Config.sections[SectionOfSectionsListForTest.name][id] "}
{"text": ""}
{"text": "import os  import tempfile      class NamedTemporaryFile:      def __init__(self, content=None):          with tempfile.NamedTemporaryFile(\"w\", delete=False) as fd:              if content:                  fd.write(content)              self.filename = fd.name        def read(self):          with open(self.filename, \"r\") as fp:              return fp.read()        def __del__(self):          os.unlink(self.filename) "}
{"text": "from copy import copy  from typing import Any, Dict, Optional    from src.taipy.config import Config, Section  from src.taipy.config._config import _Config  from src.taipy.config.common._config_blocker import _ConfigBlocker      class SectionForTest(Section):        name = \"section_name\"      _MY_ATTRIBUTE_KEY = \"attribute\"        def __init__(self, id: str, attribute: Any = None, **properties):          self._attribute = attribute          super().__init__(id, **properties)        def __copy__(self):          return SectionForTest(self.id, self._attribute, **copy(self._properties))        @property      def attribute(self):          return self._replace_templates(self._attribute)        @attribute.setter  # type: ignore      @_ConfigBlocker._check()      def attribute(self, val):          self._attribute = val        def _clean(self):          self._attribute = None          self._properties.clear()        def _to_dict(self):          as_dict = {}          if self._attribute is not None:              as_dict[self._MY_ATTRIBUTE_KEY] = self._attribute          as_dict.update(self._properties)          return as_dict        @classmethod      def _from_dict(cls, as_dict: Dict[str, Any], id: str, config: Optional[_Config] = None):          as_dict.pop(cls._ID_KEY, id)          attribute = as_dict.pop(cls._MY_ATTRIBUTE_KEY, None)          return SectionForTest(id=id, attribute=attribute, **as_dict)        def _update(self, as_dict: Dict[str, Any], default_section=None):          self._attribute = as_dict.pop(self._MY_ATTRIBUTE_KEY, self._attribute)          if self._attribute is None and default_section:              self._attribute = default_section._attribute          self._properties.update(as_dict)          if default_section:              self._properties = {**default_section.properties, **self._properties}        @staticmethod      def _configure(id: str, attribute: str, **properties):          section = SectionForTest(id, attribute, **properties)          Config._register(section)          return Config.sections[SectionForTest.name][id] "}
{"text": "from copy import copy  from typing import Any, Dict, Optional    from src.taipy.config import Config  from src.taipy.config._config import _Config  from src.taipy.config.common._config_blocker import _ConfigBlocker  from src.taipy.config.unique_section import UniqueSection      class UniqueSectionForTest(UniqueSection):        name = \"unique_section_name\"      _MY_ATTRIBUTE_KEY = \"attribute\"        def __init__(self, attribute: str = None, **properties):          self._attribute = attribute          super().__init__(**properties)        def __copy__(self):          return UniqueSectionForTest(self._attribute, **copy(self._properties))        @property      def attribute(self):          return self._replace_templates(self._attribute)        @attribute.setter  # type: ignore      @_ConfigBlocker._check()      def attribute(self, val):          self._attribute = val        def _clean(self):          self._attribute = None          self._properties.clear()        def _to_dict(self):          as_dict = {}          if self._attribute is not None:              as_dict[self._MY_ATTRIBUTE_KEY] = self._attribute          as_dict.update(self._properties)          return as_dict        @classmethod      def _from_dict(cls, as_dict: Dict[str, Any], id=None, config: Optional[_Config] = None):          as_dict.pop(cls._ID_KEY, None)          attribute = as_dict.pop(cls._MY_ATTRIBUTE_KEY, None)          return UniqueSectionForTest(attribute=attribute, **as_dict)        def _update(self, as_dict: Dict[str, Any], default_section=None):          self._attribute = as_dict.pop(self._MY_ATTRIBUTE_KEY, self._attribute)          if self._attribute is None and default_section:              self._attribute = default_section._attribute          self._properties.update(as_dict)          if default_section:              self._properties = {**default_section.properties, **self._properties}        @staticmethod      def _configure(attribute: str, **properties):          section = UniqueSectionForTest(attribute, **properties)          Config._register(section)          return Config.unique_sections[UniqueSectionForTest.name] "}
{"text": "import pytest    from src.taipy.config.common._validate_id import _validate_id  from src.taipy.config.exceptions.exceptions import InvalidConfigurationId      class TestId:      def test_validate_id(self):          s = _validate_id(\"foo\")          assert s == \"foo\"          with pytest.raises(InvalidConfigurationId):              _validate_id(\"1foo\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"foo bar\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"foo/foo$\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\" \")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"class\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"def\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"with\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"CYCLE\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"SCENARIO\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"SEQUENCE\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"TASK\")          with pytest.raises(InvalidConfigurationId):              _validate_id(\"DATANODE\") "}
{"text": "import pytest    from src.taipy.config.common.scope import Scope      def test_scope():      # Test __ge__ method      assert Scope.GLOBAL >= Scope.GLOBAL      assert Scope.GLOBAL >= Scope.CYCLE      assert Scope.CYCLE >= Scope.CYCLE      assert Scope.GLOBAL >= Scope.SCENARIO      assert Scope.CYCLE >= Scope.SCENARIO      assert Scope.SCENARIO >= Scope.SCENARIO      with pytest.raises(TypeError):          assert Scope.SCENARIO >= \"testing string\"        # Test __gt__ method      assert Scope.GLOBAL > Scope.CYCLE      assert Scope.GLOBAL > Scope.SCENARIO      assert Scope.CYCLE > Scope.SCENARIO      with pytest.raises(TypeError):          assert Scope.SCENARIO > \"testing string\"        # Test __le__ method      assert Scope.GLOBAL <= Scope.GLOBAL      assert Scope.CYCLE <= Scope.GLOBAL      assert Scope.CYCLE <= Scope.CYCLE      assert Scope.SCENARIO <= Scope.GLOBAL      assert Scope.SCENARIO <= Scope.CYCLE      assert Scope.SCENARIO <= Scope.SCENARIO      with pytest.raises(TypeError):          assert Scope.SCENARIO <= \"testing string\"        # Test __lt__ method      assert Scope.SCENARIO < Scope.GLOBAL      assert Scope.SCENARIO < Scope.GLOBAL      assert Scope.SCENARIO < Scope.CYCLE      with pytest.raises(TypeError):          assert Scope.SCENARIO < \"testing string\" "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import argparse  import re  import sys    import pytest    from src.taipy._cli._base_cli import _CLI    if sys.version_info >= (3, 10):      argparse_options_str = \"options:\"  else:      argparse_options_str = \"optional arguments:\"      def preprocess_stdout(stdout):      stdout = stdout.replace(\"\\n\", \" \").replace(\"\\t\", \" \")      return re.sub(\" +\", \" \", stdout)      def remove_subparser(name: str):      \"\"\"Remove a subparser from argparse.\"\"\"      _CLI._sub_taipyparsers.pop(name, None)        if _CLI._subparser_action:          _CLI._subparser_action._name_parser_map.pop(name, None)            for action in _CLI._subparser_action._choices_actions:              if action.dest == name:                  _CLI._subparser_action._choices_actions.remove(action)      @pytest.fixture(autouse=True, scope=\"function\")  def clean_argparser():      _CLI._parser = argparse.ArgumentParser(conflict_handler=\"resolve\")      _CLI._arg_groups = {}      subcommands = list(_CLI._sub_taipyparsers.keys())      for subcommand in subcommands:          remove_subparser(subcommand)        yield      def test_subparser(capfd):      subcommand_1 = _CLI._add_subparser(\"subcommand_1\", help=\"subcommand_1 help\")      subcommand_1.add_argument(\"--foo\", \"-f\", help=\"foo help\")      subcommand_1.add_argument(\"--bar\", \"-b\", help=\"bar help\")        subcommand_2 = _CLI._add_subparser(\"subcommand_2\", help=\"subcommand_2 help\")      subcommand_2.add_argument(\"--doo\", \"-d\", help=\"doo help\")      subcommand_2.add_argument(\"--baz\", \"-z\", help=\"baz help\")        expected_subcommand_1_help_message = f\"\"\"subcommand_1 [-h] [--foo FOO] [--bar BAR]    {argparse_options_str}    -h, --help         show this help message and exit    --foo FOO, -f FOO  foo help    --bar BAR, -b BAR  bar help      \"\"\"        subcommand_1.print_help()      stdout, _ = capfd.readouterr()      assert preprocess_stdout(expected_subcommand_1_help_message) in preprocess_stdout(stdout)        expected_subcommand_2_help_message = f\"\"\"subcommand_2 [-h] [--doo DOO] [--baz BAZ]    {argparse_options_str}    -h, --help         show this help message and exit    --doo DOO, -d DOO  doo help    --baz BAZ, -z BAZ  baz help      \"\"\"        subcommand_2.print_help()      stdout, _ = capfd.readouterr()      assert preprocess_stdout(expected_subcommand_2_help_message) in preprocess_stdout(stdout)      def test_duplicate_subcommand():      subcommand_1 = _CLI._add_subparser(\"subcommand_1\", help=\"subcommand_1 help\")      subcommand_1.add_argument(\"--foo\", \"-f\", help=\"foo help\")        subcommand_2 = _CLI._add_subparser(\"subcommand_1\", help=\"subcommand_2 help\")      subcommand_2.add_argument(\"--bar\", \"-b\", help=\"bar help\")        # The title of subcommand_2 is duplicated with  subcommand_1, and therefore      # there will be no new subcommand created      assert len(_CLI._sub_taipyparsers) == 1      def test_groupparser(capfd):      group_1 = _CLI._add_groupparser(\"group_1\", \"group_1 desc\")      group_1.add_argument(\"--foo\", \"-f\", help=\"foo help\")      group_1.add_argument(\"--bar\", \"-b\", help=\"bar help\")        group_2 = _CLI._add_groupparser(\"group_2\", \"group_2 desc\")      group_2.add_argument(\"--doo\", \"-d\", help=\"doo help\")      group_2.add_argument(\"--baz\", \"-z\", help=\"baz help\")        expected_help_message = \"\"\"  group_1:    group_1 desc      --foo FOO, -f FOO  foo help    --bar BAR, -b BAR  bar help    group_2:    group_2 desc      --doo DOO, -d DOO  doo help    --baz BAZ, -z BAZ  baz help      \"\"\".strip()        _CLI._parser.print_help()      stdout, _ = capfd.readouterr()        assert expected_help_message in stdout      def test_duplicate_group():      group_1 = _CLI._add_groupparser(\"group_1\", \"group_1 desc\")      group_1.add_argument(\"--foo\", \"-f\", help=\"foo help\")        group_2 = _CLI._add_groupparser(\"group_1\", \"group_2 desc\")      group_2.add_argument(\"--bar\", \"-b\", help=\"bar help\")        # The title of group_2 is duplicated with  group_1, and therefore      # there will be no new group created      assert len(_CLI._arg_groups) == 1 "}
{"text": "import pytest    from src.taipy.config.common._classproperty import _Classproperty      class TestClassProperty:      def test_class_property(self):          class TestClass:              @_Classproperty              def test_property(cls):                  return \"test_property\"            assert TestClass.test_property == \"test_property\"          assert TestClass().test_property == \"test_property\"          with pytest.raises(TypeError):              TestClass.test_property() "}
{"text": "import os  from unittest import mock    import pytest    from src.taipy.config.config import Config  from src.taipy.config.exceptions.exceptions import ConfigurationUpdateBlocked      def test_global_config_with_env_variable_value():      with mock.patch.dict(os.environ, {\"FOO\": \"bar\", \"BAZ\": \"qux\"}):          Config.configure_global_app(foo=\"ENV[FOO]\", bar=\"ENV[BAZ]\")          assert Config.global_config.foo == \"bar\"          assert Config.global_config.bar == \"qux\"      def test_default_global_app_config():      global_config = Config.global_config      assert global_config is not None      assert not global_config.notification      assert len(global_config.properties) == 0      def test_block_update_global_app_config():      Config.block_update()        with pytest.raises(ConfigurationUpdateBlocked):          Config.configure_global_app(foo=\"bar\")        with pytest.raises(ConfigurationUpdateBlocked):          Config.global_config.properties = {\"foo\": \"bar\"}        # Test if the global_config stay as default      assert Config.global_config.foo is None      assert len(Config.global_config.properties) == 0 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from importlib.util import find_spec    if find_spec(\"taipy\"):      if find_spec(\"taipy.config\"):          from taipy.config._init import *  # type: ignore        if find_spec(\"taipy.gui\"):          from taipy.gui._init import *  # type: ignore        if find_spec(\"taipy.core\"):          from taipy.core._init import *  # type: ignore        if find_spec(\"taipy.rest\"):          from taipy.rest._init import *  # type: ignore        if find_spec(\"taipy.gui_core\"):          from taipy.gui_core._init import *  # type: ignore        if find_spec(\"taipy.enterprise\"):          from taipy.enterprise._init import *  # type: ignore        if find_spec(\"taipy._run\"):          from taipy._run import _run as run  # type: ignore "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import logging.config  import os  import sys      class _TaipyLogger:        _ENVIRONMENT_VARIABLE_NAME_WITH_LOGGER_CONFIG_PATH = \"TAIPY_LOGGER_CONFIG_PATH\"        __logger = None        @classmethod      def _get_logger(cls):          cls._ENVIRONMENT_VARIABLE_NAME_WITH_LOGGER_CONFIG_PATH = \"TAIPY_LOGGER_CONFIG_PATH\"            if cls.__logger:              return cls.__logger            if config_filename := os.environ.get(cls._ENVIRONMENT_VARIABLE_NAME_WITH_LOGGER_CONFIG_PATH):              logging.config.fileConfig(config_filename)              cls.__logger = logging.getLogger(\"Taipy\")          else:              cls.__logger = logging.getLogger(\"Taipy\")              cls.__logger.setLevel(logging.INFO)              ch = logging.StreamHandler(sys.stdout)              ch.setLevel(logging.INFO)              formatter = logging.Formatter(\"[%(asctime)s][%(name)s][%(levelname)s] %(message)s\", \"%Y-%m-%d %H:%M:%S\")              ch.setFormatter(formatter)              cls.__logger.addHandler(ch)          return cls.__logger "}
{"text": "import json  import os      def _get_version():      with open(f\"{os.path.dirname(os.path.abspath(__file__))}{os.sep}version.json\") as version_file:          version = json.load(version_file)          version_string = f'{version.get(\"major\", 0)}.{version.get(\"minor\", 0)}.{version.get(\"patch\", 0)}'          if vext := version.get(\"ext\"):              version_string = f\"{version_string}.{vext}\"      return version_string "}
{"text": "from .config import Config  from .common.frequency import Frequency  from .common.scope import Scope "}
{"text": "\"\"\"# Taipy Config    The Taipy Config package is a Python library designed to configure a Taipy application.    The main entrypoint is the `Config^` singleton class. It exposes some methods to configure the  Taipy application and some attributes to retrieve the configuration values.    \"\"\"    from ._init import *    from typing import List  from .checker.issue import Issue  from .checker.issue_collector import IssueCollector  from .global_app.global_app_config import GlobalAppConfig  from .section import Section  from .unique_section import UniqueSection  from .version import _get_version    __version__ = _get_version()      def _config_doc(func):      def func_with_doc(section, attribute_name, default, configuration_methods, add_to_unconflicted_sections=False):          import os          if os.environ.get(\"GENERATING_TAIPY_DOC\", None) and os.environ[\"GENERATING_TAIPY_DOC\"] == \"true\":              with open(\"config_doc.txt\", \"a\") as f:                  from inspect import signature                    for exposed_configuration_method, configuration_method in configuration_methods:                      annotation = \"    @staticmethod\\n\"                      sign = \"    def \" + exposed_configuration_method + str(signature(configuration_method)) + \":\\n\"                      doc = '        \"\"\"' + configuration_method.__doc__ + '\"\"\"\\n'                      content = \"        pass\\n\\n\"                      f.write(annotation + sign + doc + content)          return func(section, attribute_name, default, configuration_methods, add_to_unconflicted_sections)        return func_with_doc      @_config_doc  def _inject_section(      section_clazz,      attribute_name: str,      default: Section,      configuration_methods: List[tuple],      add_to_unconflicted_sections: bool = False,  ):      Config._register_default(default)        if issubclass(section_clazz, UniqueSection):          setattr(Config, attribute_name, Config.unique_sections[section_clazz.name])      elif issubclass(section_clazz, Section):          setattr(Config, attribute_name, Config.sections[section_clazz.name])      else:          raise TypeError        if add_to_unconflicted_sections:          Config._comparator._add_unconflicted_section(section_clazz.name)        for exposed_configuration_method, configuration_method in configuration_methods:          setattr(Config, exposed_configuration_method, configuration_method) "}
{"text": "from abc import abstractmethod  from typing import Any, Dict, Optional    from .common._config_blocker import _ConfigBlocker  from .common._template_handler import _TemplateHandler as _tpl  from .common._validate_id import _validate_id      class Section:      \"\"\"A Section as a consistent part of the Config.        A section is defined by the section name (representing the type of objects that are configured) and a section id.      \"\"\"        _DEFAULT_KEY = \"default\"      _ID_KEY = \"id\"        def __init__(self, id, **properties):          self.id = _validate_id(id)          self._properties = properties or dict()        @abstractmethod      def __copy__(self):          raise NotImplementedError        @property      @abstractmethod      def name(self):          raise NotImplementedError        @abstractmethod      def _clean(self):          raise NotImplementedError        @abstractmethod      def _to_dict(self):          raise NotImplementedError        @classmethod      @abstractmethod      def _from_dict(cls, config_as_dict: Dict[str, Any], id, config):          raise NotImplementedError        @abstractmethod      def _update(self, config_as_dict, default_section=None):          raise NotImplementedError        def __getattr__(self, item: str) -> Optional[Any]:          return self._replace_templates(self._properties.get(item, None))        @property      def properties(self):          return {k: _tpl._replace_templates(v) for k, v in self._properties.items()}        @properties.setter  # type: ignore      @_ConfigBlocker._check()      def properties(self, val):          self._properties = val        def _replace_templates(self, value):          return _tpl._replace_templates(value) "}
{"text": "from abc import ABC    from .common._validate_id import _validate_id  from .section import Section      class UniqueSection(Section, ABC):      \"\"\"A UniqueSection is a configuration `Section^` that can have only one instance.        A UniqueSection is only defined by the section name.      \"\"\"        def __init__(self, **properties):          super().__init__(self.name, **properties) "}
{"text": "from copy import copy  from typing import Dict    from .global_app.global_app_config import GlobalAppConfig  from .section import Section  from .unique_section import UniqueSection      class _Config:      DEFAULT_KEY = \"default\"        def __init__(self):          self._sections: Dict[str, Dict[str, Section]] = {}          self._unique_sections: Dict[str, UniqueSection] = {}          self._global_config: GlobalAppConfig = GlobalAppConfig()        def _clean(self):          self._global_config._clean()          for unique_section in self._unique_sections.values():              unique_section._clean()          for sections in self._sections.values():              for section in sections.values():                  section._clean()        @classmethod      def _default_config(cls):          config = _Config()          config._global_config = GlobalAppConfig.default_config()          return config        def _update(self, other_config):          self._global_config._update(other_config._global_config._to_dict())          if other_config._unique_sections:              for section_name, other_section in other_config._unique_sections.items():                  if section := self._unique_sections.get(section_name, None):                      section._update(other_section._to_dict())                  else:                      self._unique_sections[section_name] = copy(other_config._unique_sections[section_name])          if other_config._sections:              for section_name, other_non_unique_sections in other_config._sections.items():                  if non_unique_sections := self._sections.get(section_name, None):                      self.__update_sections(non_unique_sections, other_non_unique_sections)                  else:                      self._sections[section_name] = {}                      self.__add_sections(self._sections[section_name], other_non_unique_sections)        def __add_sections(self, entity_config, other_entity_configs):          for cfg_id, sub_config in other_entity_configs.items():              entity_config[cfg_id] = copy(sub_config)              self.__point_nested_section_to_self(sub_config)        def __update_sections(self, entity_config, other_entity_configs):          if self.DEFAULT_KEY in other_entity_configs:              if self.DEFAULT_KEY in entity_config:                  entity_config[self.DEFAULT_KEY]._update(other_entity_configs[self.DEFAULT_KEY]._to_dict())              else:                  entity_config[self.DEFAULT_KEY] = other_entity_configs[self.DEFAULT_KEY]          for cfg_id, sub_config in other_entity_configs.items():              if cfg_id != self.DEFAULT_KEY:                  if cfg_id in entity_config:                      entity_config[cfg_id]._update(sub_config._to_dict(), entity_config.get(self.DEFAULT_KEY))                  else:                      entity_config[cfg_id] = copy(sub_config)                      entity_config[cfg_id]._update(sub_config._to_dict(), entity_config.get(self.DEFAULT_KEY))              self.__point_nested_section_to_self(sub_config)        def __point_nested_section_to_self(self, section):          \"\"\"Loop through attributes of a Section to find if any attribute has a list of Section as value.          If there is, update each nested Section by the corresponding instance in self.            Args:              section (Section): The Section to search for nested sections.          \"\"\"          for _, attr_value in vars(section).items():              # ! This will fail if an attribute is a dictionary, or nested list of Sections.              if not isinstance(attr_value, list):                  continue                for index, item in enumerate(attr_value):                  if not isinstance(item, Section):                      continue                    if sub_item := self._sections.get(item.name, {}).get(item.id, None):                      attr_value[index] = sub_item "}
{"text": "import toml  # type: ignore    from .._config import _Config  from ..exceptions.exceptions import LoadingError  from ._base_serializer import _BaseSerializer      class _TomlSerializer(_BaseSerializer):      \"\"\"Convert configuration from TOML representation to Python Dict and reciprocally.\"\"\"        @classmethod      def _write(cls, configuration: _Config, filename: str):          with open(filename, \"w\") as fd:              toml.dump(cls._str(configuration), fd)        @classmethod      def _read(cls, filename: str) -> _Config:          try:              config_as_dict = cls._pythonify(dict(toml.load(filename)))              return cls._from_dict(config_as_dict)          except toml.TomlDecodeError as e:              error_msg = f\"Can not load configuration {e}\"              raise LoadingError(error_msg)        @classmethod      def _serialize(cls, configuration: _Config) -> str:          return toml.dumps(cls._str(configuration))        @classmethod      def _deserialize(cls, config_as_string: str) -> _Config:          return cls._from_dict(cls._pythonify(dict(toml.loads(config_as_string)))) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import json  # type: ignore    from .._config import _Config  from ..exceptions.exceptions import LoadingError  from ._base_serializer import _BaseSerializer      class _JsonSerializer(_BaseSerializer):      \"\"\"Convert configuration from JSON representation to Python Dict and reciprocally.\"\"\"        @classmethod      def _write(cls, configuration: _Config, filename: str):          with open(filename, \"w\") as fd:              json.dump(cls._str(configuration), fd, ensure_ascii=False, indent=0, check_circular=False)        @classmethod      def _read(cls, filename: str) -> _Config:          try:              with open(filename) as f:                  config_as_dict = cls._pythonify(json.load(f))              return cls._from_dict(config_as_dict)          except json.JSONDecodeError as e:              error_msg = f\"Can not load configuration {e}\"              raise LoadingError(error_msg)        @classmethod      def _serialize(cls, configuration: _Config) -> str:          return json.dumps(cls._str(configuration), ensure_ascii=False, indent=0, check_circular=False)        @classmethod      def _deserialize(cls, config_as_string: str) -> _Config:          return cls._from_dict(cls._pythonify(dict(json.loads(config_as_string)))) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from typing import Any, List    from .issue import Issue      class IssueCollector:      \"\"\"      A collection of issues (instances of class `Issue^`).        Attributes:          errors (List[Issue^]): List of ERROR issues collected.          warnings (List[Issue^]): List WARNING issues collected.          infos (List[Issue^]): List INFO issues collected.          all (List[Issue^]): List of all issues collected ordered by decreasing level (ERROR, WARNING and INFO).      \"\"\"        _ERROR_LEVEL = \"ERROR\"      _WARNING_LEVEL = \"WARNING\"      _INFO_LEVEL = \"INFO\"        def __init__(self):          self._errors: List[Issue] = []          self._warnings: List[Issue] = []          self._infos: List[Issue] = []        @property      def all(self) -> List[Issue]:          return self._errors + self._warnings + self._infos        @property      def infos(self) -> List[Issue]:          return self._infos        @property      def warnings(self) -> List[Issue]:          return self._warnings        @property      def errors(self) -> List[Issue]:          return self._errors        def _add_error(self, field: str, value: Any, message: str, checker_name: str):          self._errors.append(Issue(self._ERROR_LEVEL, field, value, message, checker_name))        def _add_warning(self, field: str, value: Any, message: str, checker_name: str):          self._warnings.append(Issue(self._WARNING_LEVEL, field, value, message, checker_name))        def _add_info(self, field: str, value: Any, message: str, checker_name: str):          self._infos.append(Issue(self._INFO_LEVEL, field, value, message, checker_name)) "}
{"text": "from dataclasses import dataclass  from typing import Any, Optional      @dataclass  class Issue:      \"\"\"      An issue detected in the configuration.        Attributes:          level (str): Level of the issue among ERROR, WARNING, INFO.          field (str): Configuration field on which the issue has been detected.          value (Any): Value of the field on which the issue has been detected.          message (str): Human readable message to help the user fix the issue.          tag (Optional[str]): Optional tag to be used to filter issues.      \"\"\"        level: str      field: str      value: Any      message: str      tag: Optional[str]        def __str__(self) -> str:          message = self.message            if self.value:              current_value_str = f'\"{self.value}\"' if isinstance(self.value, str) else f\"{self.value}\"              message += f\" Current value of property `{self.field}` is {current_value_str}.\"            return message "}
{"text": "from typing import List    from ._checkers._config_checker import _ConfigChecker  from .issue_collector import IssueCollector      class _Checker:      \"\"\"Holds the various checkers to perform on the config.\"\"\"        _checkers: List[_ConfigChecker] = []        @classmethod      def _check(cls, _applied_config):          collector = IssueCollector()          for checker in cls._checkers:              checker(_applied_config, collector)._check()          return collector        @classmethod      def add_checker(cls, checker_class: _ConfigChecker):          cls._checkers.append(checker_class) "}
{"text": "import abc  from typing import Any, List, Optional, Set    from ..._config import _Config  from ..issue_collector import IssueCollector      class _ConfigChecker:        _PREDEFINED_PROPERTIES_KEYS = [\"_entity_owner\"]        def __init__(self, config: _Config, collector):          self._collector = collector          self._config = config        @abc.abstractmethod      def _check(self) -> IssueCollector:          raise NotImplementedError        def _error(self, field: str, value: Any, message: str):          self._collector._add_error(field, value, message, self.__class__.__name__)        def _warning(self, field: str, value: Any, message: str):          self._collector._add_warning(field, value, message, self.__class__.__name__)        def _info(self, field: str, value: Any, message: str):          self._collector._add_info(field, value, message, self.__class__.__name__)        def _check_children(          self,          parent_config_class,          config_id: str,          config_key: str,          config_value,          child_config_class,          can_be_empty: Optional[bool] = False,      ):          if not config_value and not can_be_empty:              self._warning(                  config_key,                  config_value,                  f\"{config_key} field of {parent_config_class.__name__} `{config_id}` is empty.\",              )          else:              if not (                  (isinstance(config_value, List) or isinstance(config_value, Set))                  and all(map(lambda x: isinstance(x, child_config_class), config_value))              ):                  self._error(                      config_key,                      config_value,                      f\"{config_key} field of {parent_config_class.__name__} `{config_id}` must be populated with a list \"                      f\"of {child_config_class.__name__} objects.\",                  )        def _check_existing_config_id(self, config):          if not config.id:              self._error(                  \"config_id\",                  config.id,                  f\"config_id of {config.__class__.__name__} `{config.id}` is empty.\",              )        def _check_if_entity_property_key_used_is_predefined(self, config):          for key, value in config._properties.items():              if key in self._PREDEFINED_PROPERTIES_KEYS:                  self._error(                      key,                      value,                      f\"Properties of {config.__class__.__name__} `{config.id}` cannot have `{key}` as its property.\",                  ) "}
{"text": "from ..._config import _Config  from ..issue_collector import IssueCollector  from ._config_checker import _ConfigChecker      class _AuthConfigChecker(_ConfigChecker):      def __init__(self, config: _Config, collector: IssueCollector):          super().__init__(config, collector)        def _check(self) -> IssueCollector:          auth_config = self._config._auth_config          self._check_predefined_protocol(auth_config)          return self._collector        def _check_predefined_protocol(self, auth_config):          if auth_config.protocol == auth_config._PROTOCOL_LDAP:              self.__check_ldap(auth_config)          if auth_config.protocol == auth_config._PROTOCOL_TAIPY:              self.__check_taipy(auth_config)        def __check_taipy(self, auth_config):          if auth_config._TAIPY_ROLES not in auth_config.properties:              self._error(                  \"properties\",                  auth_config._LDAP_SERVER,                  f\"`{auth_config._LDAP_SERVER}` property must be populated when {auth_config._PROTOCOL_LDAP} is used.\",              )          if auth_config._TAIPY_PWD not in auth_config.properties:              self._warning(                  \"properties\",                  auth_config._TAIPY_PWD,                  f\"`In order to protect authentication with passwords using {auth_config._PROTOCOL_TAIPY} protocol,\"                  f\" {auth_config._TAIPY_PWD}` property can be populated.\",              )        def __check_ldap(self, auth_config):          if auth_config._LDAP_SERVER not in auth_config.properties:              self._error(                  \"properties\",                  auth_config._LDAP_SERVER,                  f\"`{auth_config._LDAP_SERVER}` attribute must be populated when {auth_config._PROTOCOL_LDAP} is used.\",              )          if auth_config._LDAP_BASE_DN not in auth_config.properties:              self._error(                  \"properties\",                  auth_config._LDAP_BASE_DN,                  f\"`{auth_config._LDAP_BASE_DN}` field must be populated when {auth_config._PROTOCOL_LDAP} is used.\",              ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "# Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.    from .exceptions import * "}
{"text": "  class LoadingError(Exception):      \"\"\"Raised if an error occurs while loading the configuration file.\"\"\"      class InconsistentEnvVariableError(Exception):      \"\"\"Inconsistency value has been detected in an environment variable referenced by the configuration.\"\"\"      class MissingEnvVariableError(Exception):      \"\"\"Environment variable referenced in configuration is missing.\"\"\"      class InvalidConfigurationId(Exception):      \"\"\"Configuration id is not valid.\"\"\"      class ConfigurationUpdateBlocked(Exception):      \"\"\"The configuration is being blocked from update by other Taipy services.\"\"\" "}
{"text": "from ..common._repr_enum import _ReprEnum      class Frequency(_ReprEnum):      \"\"\"Frequency of the recurrence of `Cycle^` and `Scenario^` objects.        The frequency must be provided in the `ScenarioConfig^`.        Each recurrent scenario is attached to the cycle corresponding to the creation date and the      frequency. In other words, each cycle represents an iteration and contains the various scenarios      created during this iteration.        For instance, when scenarios have a _MONTHLY_ frequency, one cycle will be created for each      month (January, February, March, etc.). A new scenario created on February 10th, gets      attached to the _February_ cycle.        The frequency is implemented as an enumeration with the following possible values:        - With a _DAILY_ frequency, a new cycle is created for each day.        - With a _WEEKLY_ frequency, a new cycle is created for each week (from Monday to Sunday).        - With a _MONTHLY_ frequency, a new cycle is created for each month.        - With a _QUARTERLY_ frequency, a new cycle is created for each quarter.        - With a _YEARLY_ frequency, a new cycle is created for each year.      \"\"\"        DAILY = 1      WEEKLY = 2      MONTHLY = 3      QUARTERLY = 4      YEARLY = 5 "}
{"text": "class _Classproperty(object):      def __init__(self, f):          self.f = f        def __get__(self, obj, owner):          return self.f(owner) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import functools  from enum import Enum      class _ReprEnum(Enum):      @classmethod      @functools.lru_cache      def _from_repr(cls, repr_: str):          return next(filter(lambda e: repr(e) == repr_, cls))  # type: ignore "}
{"text": "import keyword    from ..exceptions.exceptions import InvalidConfigurationId    __INVALID_TAIPY_ID_TERMS = [\"CYCLE\", \"SCENARIO\", \"SEQUENCE\", \"TASK\", \"DATANODE\"]      def _validate_id(name: str):      for invalid_taipy_id_term in __INVALID_TAIPY_ID_TERMS:          if invalid_taipy_id_term in name:              raise InvalidConfigurationId(f\"{name} is not a valid identifier. {invalid_taipy_id_term} is restricted.\")        if name.isidentifier() and not keyword.iskeyword(name):          return name        raise InvalidConfigurationId(f\"{name} is not a valid identifier.\") "}
{"text": "import functools    from ...logger._taipy_logger import _TaipyLogger  from ..exceptions.exceptions import ConfigurationUpdateBlocked      class _ConfigBlocker:      \"\"\"Configuration blocker singleton.\"\"\"        __logger = _TaipyLogger._get_logger()      __block_config_update = False        @classmethod      def _block(cls):          cls.__block_config_update = True        @classmethod      def _unblock(cls):          cls.__block_config_update = False        @classmethod      def _check(cls):          def inner(f):              @functools.wraps(f)              def _check_if_is_blocking(*args, **kwargs):                  if cls.__block_config_update:                      error_message = (                          \"The Core service should be stopped by running core.stop() before\"                          \" modifying the Configuration. For more information, please refer to:\"                          \" https://docs.taipy.io/en/latest/manuals/running_services/#running-core.\"                      )                      cls.__logger.error(\"ConfigurationUpdateBlocked: \" + error_message)                      raise ConfigurationUpdateBlocked(error_message)                    return f(*args, **kwargs)                return _check_if_is_blocking            return inner "}
{"text": "from ..common._repr_enum import _ReprEnum      class _OrderedEnum(_ReprEnum):      def __ge__(self, other):          if self.__class__ is other.__class__:              return self.value >= other.value          return NotImplemented        def __gt__(self, other):          if self.__class__ is other.__class__:              return self.value > other.value          return NotImplemented        def __le__(self, other):          if self.__class__ is other.__class__:              return self.value <= other.value          return NotImplemented        def __lt__(self, other):          if self.__class__ is other.__class__:              return self.value < other.value          return NotImplemented      class Scope(_OrderedEnum):      \"\"\"Scope of a `DataNode^`.        This enumeration can have the following values:        - `GLOBAL`      - `CYCLE`      - `SCENARIO`      \"\"\"        GLOBAL = 3      CYCLE = 2      SCENARIO = 1 "}
{"text": "import os  import re  from collections import UserDict  from datetime import datetime, timedelta  from importlib import import_module  from operator import attrgetter  from pydoc import locate    from ..exceptions.exceptions import InconsistentEnvVariableError, MissingEnvVariableError  from .frequency import Frequency  from .scope import Scope      class _TemplateHandler:      \"\"\"Factory to handle actions related to config value templating.\"\"\"        _PATTERN = r\"^ENV\\[([a-zA-Z_]\\w*)\\](:(\\bbool\\b|\\bstr\\b|\\bfloat\\b|\\bint\\b))?$\"        @classmethod      def _replace_templates(cls, template, type=str, required=True, default=None):          if isinstance(template, tuple):              return tuple(cls._replace_template(item, type, required, default) for item in template)          if isinstance(template, list):              return [cls._replace_template(item, type, required, default) for item in template]          if isinstance(template, dict):              return {str(k): cls._replace_template(v, type, required, default) for k, v in template.items()}          if isinstance(template, UserDict):              return {str(k): cls._replace_template(v, type, required, default) for k, v in template.items()}          return cls._replace_template(template, type, required, default)        @classmethod      def _replace_template(cls, template, type, required, default):          if \"ENV\" not in str(template):              return template          match = re.fullmatch(cls._PATTERN, str(template))          if match:              var = match.group(1)              dynamic_type = match.group(3)              val = os.environ.get(var)              if val is None:                  if required:                      raise MissingEnvVariableError(f\"Environment variable {var} is not set.\")                  return default              if type == bool:                  return cls._to_bool(val)              elif type == int:                  return cls._to_int(val)              elif type == float:                  return cls._to_float(val)              elif type == Scope:                  return cls._to_scope(val)              elif type == Frequency:                  return cls._to_frequency(val)              else:                  if dynamic_type == \"bool\":                      return cls._to_bool(val)                  elif dynamic_type == \"int\":                      return cls._to_int(val)                  elif dynamic_type == \"float\":                      return cls._to_float(val)                  return val          return template        @staticmethod      def _to_bool(val: str) -> bool:          possible_values = [\"true\", \"false\"]          if str.lower(val) not in possible_values:              raise InconsistentEnvVariableError(\"{val} is not a Boolean.\")          return str.lower(val) == \"true\" or not (str.lower(val) == \"false\")        @staticmethod      def _to_int(val: str) -> int:          try:              return int(val)          except ValueError:              raise InconsistentEnvVariableError(f\"{val} is not an integer.\")        @staticmethod      def _to_float(val: str) -> float:          try:              return float(val)          except ValueError:              raise InconsistentEnvVariableError(f\"{val} is not a float.\")        @staticmethod      def _to_datetime(val: str) -> datetime:          try:              return datetime.fromisoformat(val)          except ValueError:              raise InconsistentEnvVariableError(f\"{val} is not a valid datetime.\")        @staticmethod      def _to_timedelta(val: str) -> timedelta:          \"\"\"          Parse a time string e.g. (2h13m) into a timedelta object.            :param timedelta_str: A string identifying a duration.  (eg. 2h13m)          :return datetime.timedelta: A datetime.timedelta object          \"\"\"          regex = re.compile(              r\"^((?P<days>[\\.\\d]+?)d)? *\"              r\"((?P<hours>[\\.\\d]+?)h)? *\"              r\"((?P<minutes>[\\.\\d]+?)m)? *\"              r\"((?P<seconds>[\\.\\d]+?)s)?$\"          )          parts = regex.match(val)          if not parts:              raise InconsistentEnvVariableError(f\"{val} is not a valid timedelta.\")          time_params = {name: float(param) for name, param in parts.groupdict().items() if param}          return timedelta(**time_params)  # type: ignore        @staticmethod      def _to_scope(val: str) -> Scope:          try:              return Scope[str.upper(val)]          except Exception:              raise InconsistentEnvVariableError(f\"{val} is not a valid scope.\")        @staticmethod      def _to_frequency(val: str) -> Frequency:          try:              return Frequency[str.upper(val)]          except Exception:              raise InconsistentEnvVariableError(f\"{val} is not a valid frequency.\")        @staticmethod      def _to_function(val: str):          module_name, fct_name = val.rsplit(\".\", 1)          try:              module = import_module(module_name)              return attrgetter(fct_name)(module)          except Exception:              raise InconsistentEnvVariableError(f\"{val} is not a valid function.\")        @staticmethod      def _to_class(val: str):          try:              return locate(val)          except Exception:              raise InconsistentEnvVariableError(f\"{val} is not a valid class.\") "}
{"text": ""}
{"text": "from __future__ import annotations    from typing import Any, Dict, Optional, Union    from ..common._config_blocker import _ConfigBlocker  from ..common._template_handler import _TemplateHandler as _tpl      class GlobalAppConfig:      \"\"\"      Configuration fields related to the global application.        Attributes:          **properties (Dict[str, Any]): A dictionary of additional properties.      \"\"\"        def __init__(self, **properties):          self._properties = properties        @property      def properties(self):          return {k: _tpl._replace_templates(v) for k, v in self._properties.items()}        @properties.setter  # type: ignore      @_ConfigBlocker._check()      def properties(self, val):          self._properties = val        def __getattr__(self, item: str) -> Optional[Any]:          return _tpl._replace_templates(self._properties.get(item))        @classmethod      def default_config(cls) -> GlobalAppConfig:          return GlobalAppConfig()        def _clean(self):          self._properties.clear()        def _to_dict(self):          as_dict = {}          as_dict.update(self._properties)          return as_dict        @classmethod      def _from_dict(cls, config_as_dict: Dict[str, Any]):          config = GlobalAppConfig()          config._properties = config_as_dict          return config        def _update(self, config_as_dict):          self._properties.update(config_as_dict) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import argparse  from typing import Dict      class _CLI:      \"\"\"Argument parser for Taipy application.\"\"\"        # The conflict_handler is set to \"resolve\" to override conflict arguments      _subparser_action = None      _parser = argparse.ArgumentParser(conflict_handler=\"resolve\")        _sub_taipyparsers: Dict[str, argparse.ArgumentParser] = {}      _arg_groups: Dict[str, argparse._ArgumentGroup] = {}        @classmethod      def _add_subparser(cls, name: str, **kwargs) -> argparse.ArgumentParser:          \"\"\"Create a new subparser and return a argparse handler.\"\"\"          if subparser := cls._sub_taipyparsers.get(name):              return subparser            if not cls._subparser_action:              cls._subparser_action = cls._parser.add_subparsers()            subparser = cls._subparser_action.add_parser(              name=name,              conflict_handler=\"resolve\",              **kwargs,          )          cls._sub_taipyparsers[name] = subparser          subparser.set_defaults(which=name)          return subparser        @classmethod      def _add_groupparser(cls, title: str, description: str = \"\") -> argparse._ArgumentGroup:          \"\"\"Create a new group for arguments and return a argparser handler.\"\"\"          if groupparser := cls._arg_groups.get(title):              return groupparser            groupparser = cls._parser.add_argument_group(title=title, description=description)          cls._arg_groups[title] = groupparser          return groupparser        @classmethod      def _parse(cls):          \"\"\"Parse and return only known arguments.\"\"\"          args, _ = cls._parser.parse_known_args()          return args        @classmethod      def _remove_argument(cls, arg: str):          \"\"\"Remove an argument from the parser. Note that the `arg` must be without --.            Source: https://stackoverflow.com/questions/32807319/disable-remove-argument-in-argparse          \"\"\"          for action in cls._parser._actions:              opts = action.option_strings              if (opts and opts[0] == arg) or action.dest == arg:                  cls._parser._remove_action(action)                  break            for argument_group in cls._parser._action_groups:              for group_action in argument_group._group_actions:                  opts = group_action.option_strings                  if (opts and opts[0] == arg) or group_action.dest == arg:                      argument_group._group_actions.remove(group_action)                      return "}
{"text": "from ._cli import _CLI "}
{"text": "\"\"\"The setup script.\"\"\"    import json  import os    from setuptools import find_namespace_packages, find_packages, setup    with open(\"README.md\", \"rb\") as readme_file:      readme = readme_file.read().decode(\"UTF-8\")    with open(f\"src{os.sep}taipy{os.sep}templates{os.sep}version.json\") as version_file:      version = json.load(version_file)      version_string = f'{version.get(\"major\", 0)}.{version.get(\"minor\", 0)}.{version.get(\"patch\", 0)}'      if vext := version.get(\"ext\"):          version_string = f\"{version_string}.{vext}\"    test_requirements = [\"pytest>=3.8\"]    setup(      author=\"Avaiga\",      author_email=\"dev@taipy.io\",      python_requires=\">=3.8\",      classifiers=[          \"Intended Audience :: Developers\",          \"License :: OSI Approved :: Apache Software License\",          \"Natural Language :: English\",          \"Programming Language :: Python :: 3\",          \"Programming Language :: Python :: 3.8\",          \"Programming Language :: Python :: 3.9\",          \"Programming Language :: Python :: 3.10\",          \"Programming Language :: Python :: 3.11\",      ],      description=\"An open-source package holding Taipy application templates.\",      license=\"Apache License 2.0\",      long_description=readme,      long_description_content_type=\"text/markdown\",      keywords=\"taipy-templates\",      name=\"taipy-templates\",      package_dir={\"\": \"src\"},      packages=find_namespace_packages(where=\"src\") + find_packages(include=[\"taipy\"]),      include_package_data=True,      test_suite=\"tests\",      url=\"https://github.com/avaiga/taipy-templates\",      version=version_string,      zip_safe=False,  ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import subprocess  import sys      def _run_template(main_path, time_out=30):      \"\"\"Run the templates on a subprocess and get stdout after timeout\"\"\"      with subprocess.Popen([sys.executable, main_path], stdout=subprocess.PIPE, stderr=subprocess.PIPE) as proc:          try:              stdout, stderr = proc.communicate(timeout=time_out)          except subprocess.TimeoutExpired:              proc.kill()              stdout, stderr = proc.communicate()        # Print the eror if there is any (for debugging)      if stderr := str(stderr, \"utf-8\"):          print(stderr)        return stdout "}
{"text": "import os    from cookiecutter.main import cookiecutter    from .utils import _run_template      def test_scenario_management_with_toml_config(tmpdir):      cookiecutter(          template=\"src/taipy/templates/scenario-management\",          output_dir=tmpdir,          no_input=True,          extra_context={              \"Application root folder name\": \"foo_app\",              \"Application main Python file\": \"main.py\",              \"Application title\": \"bar\",              \"Does the application use TOML Config?\": \"yes\",          },      )        assert os.listdir(tmpdir) == [\"foo_app\"]      assert (          os.listdir(os.path.join(tmpdir, \"foo_app\")).sort()          == [\"requirements.txt\", \"main.py\", \"algos\", \"config\", \"pages\"].sort()      )        # Assert post_gen_project hook is successful      with open(os.path.join(tmpdir, \"foo_app\", \"requirements.txt\")) as requirements_file:          assert \"taipy==\" in requirements_file.read()      assert (          os.listdir(os.path.join(tmpdir, \"foo_app\", \"config\")).sort()          == [\"__init__.py\", \"config.py\", \"config.toml\"].sort()      )      with open(os.path.join(tmpdir, \"foo_app\", \"config\", \"config.py\")) as config_file:          assert 'Config.load(\"config/config.toml\")' in config_file.read()        oldpwd = os.getcwd()      os.chdir(os.path.join(tmpdir, \"foo_app\"))      stdout = _run_template(\"main.py\")      os.chdir(oldpwd)        # Assert the message when the application is run successfully is in the stdout      assert \"[Taipy][INFO] Configuration 'config/config.toml' successfully loaded.\" in str(stdout, \"utf-8\")      assert \"[Taipy][INFO]  * Server starting on\" in str(stdout, \"utf-8\")      def test_scenario_management_without_toml_config(tmpdir):      cookiecutter(          template=\"src/taipy/templates/scenario-management\",          output_dir=tmpdir,          no_input=True,          extra_context={              \"Application root folder name\": \"foo_app\",              \"Application main Python file\": \"main.py\",              \"Application title\": \"bar\",              \"Does the application use TOML Config?\": \"no\",          },      )        assert os.listdir(tmpdir) == [\"foo_app\"]      assert (          os.listdir(os.path.join(tmpdir, \"foo_app\")).sort()          == [\"requirements.txt\", \"main.py\", \"algos\", \"config\", \"pages\"].sort()      )        # Assert post_gen_project hook is successful      with open(os.path.join(tmpdir, \"foo_app\", \"requirements.txt\")) as requirements_file:          assert \"taipy==\" in requirements_file.read()      assert os.listdir(os.path.join(tmpdir, \"foo_app\", \"config\")).sort() == [\"__init__.py\", \"config.py\"].sort()      with open(os.path.join(tmpdir, \"foo_app\", \"config\", \"config.py\")) as config_file:          config_content = config_file.read()          assert 'Config.load(\"config/config.toml\")' not in config_content          assert all([x in config_content for x in [\"Config.configure_csv_data_node\", \"Config.configure_task\"]])        oldpwd = os.getcwd()      os.chdir(os.path.join(tmpdir, \"foo_app\"))      stdout = _run_template(\"main.py\")      os.chdir(oldpwd)        # Assert the message when the application is run successfully is in the stdout      assert \"[Taipy][INFO]  * Server starting on\" in str(stdout, \"utf-8\") "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from config.config import configure  from pages import job_page, scenario_page  from pages.root import content, root, selected_data_node, selected_scenario    import taipy as tp  from taipy import Core, Gui      def on_init(state):      ...      def on_change(state, var, val):      if var == \"selected_data_node\" and val:          state[\"scenario\"].manage_data_node_partial(state)      pages = {      \"/\": root,      \"scenario\": scenario_page,      \"jobs\": job_page,  }      if __name__ == \"__main__\":      # Instantiate, configure and run the Core      core = Core()      default_scenario_cfg = configure()      core.run()        # ##################################################################################################################      # PLACEHOLDER: Initialize your data application here                                                               #      #                                                                                                                  #      # Example:                                                                                                         #      if len(tp.get_scenarios()) == 0:          tp.create_scenario(default_scenario_cfg, name=\"Default Scenario\")      # Comment, remove or replace the previous lines with your own use case                                             #      # ##################################################################################################################        # Instantiate, configure and run the GUI      gui = Gui(pages=pages)      data_node_partial = gui.add_partial(\"\")      gui.run(title=\"{{cookiecutter.__application_title}}\", margin=\"0em\") "}
{"text": "from algos import clean_data    from taipy import Config, Frequency, Scope      def configure():      # ##################################################################################################################      # PLACEHOLDER: Add your scenario configurations here                                                               #      #                                                                                                                  #      # Example:                                                                                                         #      initial_dataset_cfg = Config.configure_csv_data_node(\"initial_dataset\", scope=Scope.CYCLE)      replacement_type_cfg = Config.configure_data_node(\"replacement_type\", default_data=\"NO VALUE\")      cleaned_dataset_cfg = Config.configure_csv_data_node(\"cleaned_dataset\")      clean_data_cfg = Config.configure_task(          \"clean_data\",          function=clean_data,          input=[initial_dataset_cfg, replacement_type_cfg],          output=cleaned_dataset_cfg,      )      scenario_cfg = Config.configure_scenario(          \"scenario_configuration\", task_configs=[clean_data_cfg], frequency=Frequency.DAILY      )      return scenario_cfg      # Comment, remove or replace the previous lines with your own use case                                             #      # ################################################################################################################## "}
{"text": "from taipy import Config      def configure():      Config.load(\"config/config.toml\")      return Config.scenarios[\"scenario_configuration\"] "}
{"text": ""}
{"text": "def clean_data(df, replacement_type):      df = df.fillna(replacement_type)      return df "}
{"text": "from .algos import clean_data "}
{"text": "from .scenario_page import scenario_page  from .job_page import job_page"}
{"text": "from taipy.gui import Markdown    selected_scenario = None  selected_data_node = None  content = \"\"    root = Markdown(\"pages/root.md\") "}
{"text": "from .job_page import job_page "}
{"text": "from taipy.gui import Markdown      job_page = Markdown(\"pages/job_page/job_page.md\") "}
{"text": "from taipy.gui import Markdown, notify    from .data_node_management import manage_partial      def notify_on_submission(state, submitable, details):      if details['submission_status'] == 'COMPLETED':          notify(state, \"success\", \"Submision completed!\")      elif details['submission_status'] == 'FAILED':          notify(state, \"error\", \"Submission failed!\")      else:          notify(state, \"info\", \"In progress...\")    def manage_data_node_partial(state):      manage_partial(state)    scenario_page = Markdown(\"pages/scenario_page/scenario_page.md\") "}
{"text": "from .scenario_page import scenario_page "}
{"text": "# build partial content for a specific data node  def build_dn_partial(dn, dn_label):      partial_content = \"<|part|render={selected_scenario}|\\n\\n\"        # ##################################################################################################################      # PLACEHOLDER: data node specific content before automatic content                                                 #      #                                                                                                                  #      # Example:                                                                                                         #      if dn_label == \"replacement_type\":          partial_content += \"All missing values will be replaced by the data node value.\"      # Comment, remove or replace the previous lines with your own use case                                             #      # ##################################################################################################################        # Automatic data node content      partial_content += \"<|{selected_scenario.data_nodes['\" + dn.config_id + \"']}|data_node|scenario={selected_scenario}|>\\n\\n\"        # ##################################################################################################################      # PLACEHOLDER: data node specific content after automatic content                                                  #      #                                                                                                                  #      # Example:                                                                                                         #      if dn_label == \"initial_dataset\":          partial_content += \"Select your CSV file: <|{selected_data_node.path}|file_selector|extensions=.csv|on_action={lambda s: s.refresh('selected_scenario')}|>\\n\\n\"      # Comment, remove or replace the previous lines with your own use case                                             #      # ##################################################################################################################        partial_content += \"|>\\n\\n\"      return partial_content      def manage_partial(state):      dn = state.selected_data_node      dn_label = dn.get_simple_label()      partial_content = build_dn_partial(dn, dn_label)      state.data_node_partial.update_content(state, partial_content) "}
{"text": "import os    import taipy    # Add taipy version to requirements.txt  with open(os.path.join(os.getcwd(), \"requirements.txt\"), \"a\") as requirement_file:      requirement_file.write(f\"taipy=={taipy.version._get_version()}\\n\")    # Use TOML config file or not  use_toml_config = \"{{ cookiecutter.__use_toml_config }}\".upper()  if use_toml_config == \"YES\" or use_toml_config == \"Y\":      os.remove(os.path.join(os.getcwd(), \"config\", \"config.py\"))      os.rename(          os.path.join(os.getcwd(), \"config\", \"config_with_toml.py\"), os.path.join(os.getcwd(), \"config\", \"config.py\")      )  else:      os.remove(os.path.join(os.getcwd(), \"config\", \"config_with_toml.py\"))      os.remove(os.path.join(os.getcwd(), \"config\", \"config.toml\"))    main_file_name = \"{{cookiecutter.__main_file}}.py\"  print(      f\"New Taipy application has been created at {os.path.join(os.getcwd())}\"      f\"\\n\\nTo start the application, change directory to the newly created folder:\"      f\"\\n\\tcd {os.path.join(os.getcwd())}\"      f\"\\nand run the application as follows:\"      f\"\\n\\ttaipy run {main_file_name}\"  ) "}
{"text": ""}
{"text": "\"\"\"  Contain the application's configuration including the scenario configurations.    The configuration is run by the Core service.  \"\"\"    from algorithms import *    from taipy import Config    # #############################################################################  # PLACEHOLDER: Put your application's configurations here                     #  #                                                                             #  # Example:                                                                    #  # scenario_config = Config.configure_scenario(\"placeholder_scenario\", [])     #  # Comment, remove or replace the previous lines with your own use case        #  # ############################################################################# "}
{"text": "from .config import * "}
{"text": "\"\"\"  This file is designed to contain the various Python functions used to configure tasks.    The functions will be imported by the __init__.py file in this folder.  \"\"\"    # ##################################################################################################################  # PLACEHOLDER: Put your Python functions here                                                                      #  #                                                                                                                  #  # Example:                                                                                                         #  # def place_holder_algorithm():                                                                                    #  #     pass                                                                                                         #  # Comment, remove or replace the previous lines with your own use case                                             #  # ################################################################################################################## "}
{"text": "from algorithms import * "}
{"text": "from .root import root_page "}
{"text": "\"\"\"  The root page of the application.  Page content is imported from the root.md file.    Please refer to https://docs.taipy.io/en/latest/manuals/gui/pages for more details.  \"\"\"    from taipy.gui import Markdown    root_page = Markdown(\"pages/root.md\") "}
{"text": "\"\"\"  A page of the application.  Page content is imported from the page_example.md file.    Please refer to https://docs.taipy.io/en/latest/manuals/gui/pages for more details.  \"\"\"    from taipy.gui import Markdown    page_example = Markdown(\"pages/page_example/page_example.md\") "}
{"text": "import sys    pages = \"{{ cookiecutter.__pages }}\".split(\" \")  # Remove empty string from pages list  pages = [page for page in pages if page != \"\"]    for page in pages:      if not page.isidentifier():          sys.exit(f'Page name \"{page}\" is not a valid Python identifier. Please choose another name.') "}
{"text": "import os  import threading    from flask import Flask  from pyngrok import ngrok  from hf_hub_ctranslate2 import GeneratorCT2fromHfHub    from flask import request, jsonify    model_name = \"taipy5-ct2\" # note this is local folder model, the model uploaded to huggingface did not response correctly  #model_name = \"michaelfeil/ct2fast-starchat-alpha\"  #model_name = \"michaelfeil/ct2fast-starchat-beta\"  model = GeneratorCT2fromHfHub(          # load in int8 on CUDA          model_name_or_path=model_name,          device=\"cuda\",          compute_type=\"int8_float16\",          # tokenizer=AutoTokenizer.from_pretrained(\"{ORG}/{NAME}\")  )    def generate_text_batch(prompt_texts, max_length=64):      outputs = model.generate(prompt_texts, max_length=max_length, include_prompt_in_result=False)      return outputs    app = Flask(__name__)  port = \"5000\"    # Open a ngrok tunnel to the HTTP server  public_url = ngrok.connect(port).public_url  print(\" * ngrok tunnel \\\"{}\\\" -> \\\"http://127.0.0.1:{}\\\"\".format(public_url, port))    # Update any base URLs to use the public ngrok URL  app.config[\"BASE_URL\"] = public_url    # ... Update inbound traffic via APIs to use the public-facing ngrok URL  # Define Flask routes  @app.route(\"/\")  def index():      return \"Hello from Colab!\"    @app.route(\"/api/generate\", methods=[\"POST\"])  def generate_code():      try:          # Get the JSON data from the request body          data = request.get_json()                    # Extract 'inputs' and 'parameters' from the JSON data          inputs = data.get('inputs', \"\")          parameters = data.get('parameters', {})                    # Extract the 'max_new_tokens' parameter          max_new_tokens = parameters.get('max_new_tokens', 64)            # Call the generate_text_batch function with inputs and max_new_tokens          generated_text = generate_text_batch([inputs], max_new_tokens)[0]            return jsonify({          \"generated_text\": generated_text,          \"status\": 200          })        except Exception as e:          return jsonify({\"error\": str(e)})      # Start the Flask server in a new thread  threading.Thread(target=app.run, kwargs={\"use_reloader\": False}).start() "}
{"text": "import os  import json    def tokenize_code(code, max_characters=256):      \"\"\"      Tokenize code into snippets of specified max_characters, breaking at new lines.      \"\"\"      lines = code.split('\\n')      snippets = []      current_snippet = \"\"        for line in lines:          if len(current_snippet) + len(line) + 1 <= max_characters:              current_snippet += line + '\\n'          else:              snippets.append(current_snippet.strip())              current_snippet = line + '\\n'        if current_snippet:          snippets.append(current_snippet.strip())        return snippets    def process_file(file_path):      \"\"\"      Read a file, tokenize the code, and create snippets.      \"\"\"      with open(file_path, 'r', encoding='utf-8') as file:          content = file.read()        # Tokenize code into snippets of 128 characters at new lines      snippets = tokenize_code(content)        return snippets    def escape_string(s):      \"\"\"      Do not escape triple quotes, double quotes, single quotes, and new lines.      \"\"\"      return s    def main(input_folder, output_file):      snippets_list = []        for root, dirs, files in os.walk(input_folder):          for file in files:              if file.endswith(('.py', '.md')):                  file_path = os.path.join(root, file)                  snippets = process_file(file_path)                  for snippet in snippets:                      escaped_snippet = escape_string(snippet)                      snippets_list.append({'text': escaped_snippet})        # Write snippets to a JSONL file      with open(output_file, 'w', encoding='utf-8') as jsonl_file:          for snippet in snippets_list:              jsonl_file.write(json.dumps(snippet) + '\\n')    if __name__ == \"__main__\":      input_folder = 'taipy'  # replace with your folder path      output_file = 'snippets.jsonl'  # replace with your desired output file path      main(input_folder, output_file) "}
{"text": "from taipy.gui import Gui  from tensorflow.keras import models  from PIL import Image  import numpy as np    model = models.load_model(\"assets/baseline.keras\")      class_names = {      0: \"airplane\",      1: \"automobile\",      2: \"bird\",      3: \"cat\",      4: \"deer\",      5: \"dog\",      6: \"frog\",      7: \"horse\",      8: \"ship\",      9: \"truck\",  }      def predict_image(model, path_to_image):      img = Image.open(path_to_image)      img = img.convert(\"RGB\").resize((32, 32))        # Normalizing image      data = np.asarray(img)      print(\"Before: \", data[0][0])  # Printing color of very first pixel      data = data / 255        # Comparing stuff to see if we broke something      print(\"After: \", data[0][0])  # Printing color of very first pixel        # Tricking model into thinking it is looking at an array of sample images and not a single image      probability = model.predict(np.array([data])[:1])      probes = probability.max()      prediction = class_names[np.argmax(probability)]      return (probes, prediction)      image_path = \"assets/placeholder_image.png\"  prediction, prob, content = \"\", \"\", \"\"      image_control_component = \"\"\"  <|text-center|  <|{\"assets/logo.png\"}|image|width=10vw|height=25vh|>    <|{content}|file_selector|extensions=.png|>    Select an image!      <|{prediction}|>        <|{image_path}|image|>    <|{prob}|indicator|value={prob}|min=0|max=100|width=25vw|>  >  \"\"\"      index = image_control_component      def on_change(state, variable_name, variable_value):      if variable_name == \"content\":          state.image_path = variable_value          probes, prediction = predict_image(model, variable_value)          state.prob = round(probes * 100)  # Converting decimal to percentage          state.prediction = f\"This is a : {prediction}\"      app = Gui(page=index)  if __name__ == \"__main__\":      app.run(use_reloader=True) "}
{"text": "from taipy.gui import Gui  from tensorflow.keras import models  from PIL import Image  import numpy as np    model = models.load_model(\"baseline_mariya.keras\")      class_names = {      0: \"airplane\",      1: \"automobile\",      2: \"bird\",      3: \"cat\",      4: \"deer\",      5: \"dog\",      6: \"frog\",      7: \"horse\",      8: \"ship\",      9: \"truck\",  }      def predict_image(model, path_to_image):      img = Image.open(path_to_image)      img = img.convert(\"RGB\").resize((32, 32))        # Normalizing image      data = np.asarray(img)      print(\"Before: \", data[0][0])  # Printing color of very first pixel      data = data / 255        # Comparing stuff to see if we broke something      print(\"After: \", data[0][0])  # Printing color of very first pixel        # Tricking model into thinking it is looking at an array of sample images and not a single image      probability = model.predict(np.array([data])[:1])      print(probability)      probes = probability.max()      prediction = class_names[np.argmax(probability)]      return (probes, prediction)      image_path = \"placeholder_image.png\"  prediction, prob, content = \"\", \"\", \"\"      image_control_component = \"\"\"  <|text-center|  <|{\"logo.png\"}|image|width=25vw|>    <|{content}|file_selector|extensions=.png|>    Select an image!      <|{prediction}|>        <|{image_path}|image|>    <|{prob}|indicator|value={prob}|min=0|max=100|width=25vw|>  >  \"\"\"      index = image_control_component      def on_change(state, variable_name, variable_value):      if variable_name == \"content\":          state.image_path = variable_value          probes, prediction = predict_image(model, variable_value)          state.prob = round(probes * 100)  # Converting decimal to percentage          state.prediction = f\"This is a : {prediction}\"      app = Gui(page=index)  if __name__ == \"__main__\":      app.run(use_reloader=True) "}
{"text": "print(\"Hello, World!\")  print(\"Hi Taipy!\")"}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  import json  import os    from setuptools import find_namespace_packages, find_packages, setup    with open(\"README.md\") as readme_file:      readme = readme_file.read()    with open(f\"src{os.sep}taipy{os.sep}rest{os.sep}version.json\") as version_file:      version = json.load(version_file)      version_string = f'{version.get(\"major\", 0)}.{version.get(\"minor\", 0)}.{version.get(\"patch\", 0)}'      if vext := version.get(\"ext\"):          version_string = f\"{version_string}.{vext}\"    setup(      author=\"Avaiga\",      name=\"taipy-rest\",      keywords=\"taipy-rest\",      python_requires=\">=3.8\",      version=version_string,      author_email=\"dev@taipy.io\",      packages=find_namespace_packages(where=\"src\") + find_packages(include=[\"taipy\", \"taipy.rest\"]),      package_dir={\"\": \"src\"},      include_package_data=True,      long_description=readme,      long_description_content_type=\"text/markdown\",      description=\"Library to expose taipy-core REST APIs.\",      license=\"Apache License 2.0\",      classifiers=[          \"Intended Audience :: Developers\",          \"License :: OSI Approved :: Apache Software License\",          \"Natural Language :: English\",          \"Programming Language :: Python :: 3\",          \"Programming Language :: Python :: 3.8\",          \"Programming Language :: Python :: 3.9\",          \"Programming Language :: Python :: 3.10\",          \"Programming Language :: Python :: 3.11\",      ],      install_requires=[          \"flask>=3.0.0,<3.1\",          \"flask-restful>=0.3.9,<0.4\",          \"passlib>=1.7.4,<1.8\",          \"marshmallow>=3.20.1,<3.30\",          \"apispec[yaml]>=6.3,<7.0\",          \"apispec-webframeworks>=0.5.2,<0.6\",          \"taipy-core@git+https://git@github.com/Avaiga/taipy-core.git@develop\",      ],  ) "}
{"text": "from unittest import mock    import pytest  from flask import url_for    from src.taipy.rest.api.exceptions.exceptions import ScenarioIdMissingException, SequenceNameMissingException  from taipy.core.exceptions.exceptions import NonExistingScenario  from taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory      def test_get_sequence(client, default_sequence):      # test 404      user_url = url_for(\"api.sequence_by_id\", sequence_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.sequence._sequence_manager._SequenceManager._get\") as manager_mock:          manager_mock.return_value = default_sequence            # test get_sequence          rep = client.get(url_for(\"api.sequence_by_id\", sequence_id=\"foo\"))          assert rep.status_code == 200      def test_delete_sequence(client):      # test 404      user_url = url_for(\"api.sequence_by_id\", sequence_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.sequence._sequence_manager._SequenceManager._delete\"), mock.patch(          \"taipy.core.sequence._sequence_manager._SequenceManager._get\"      ):          # test get_sequence          rep = client.delete(url_for(\"api.sequence_by_id\", sequence_id=\"foo\"))          assert rep.status_code == 200      def test_create_sequence(client, default_scenario):      sequences_url = url_for(\"api.sequences\")      rep = client.post(sequences_url, json={})      assert rep.status_code == 400      assert rep.json == {\"message\": \"Scenario id is missing.\"}        sequences_url = url_for(\"api.sequences\")      rep = client.post(sequences_url, json={\"scenario_id\": \"SCENARIO_scenario_id\"})      assert rep.status_code == 400      assert rep.json == {\"message\": \"Sequence name is missing.\"}        sequences_url = url_for(\"api.sequences\")      rep = client.post(sequences_url, json={\"scenario_id\": \"SCENARIO_scenario_id\", \"sequence_name\": \"sequence\"})      assert rep.status_code == 404        _ScenarioManagerFactory._build_manager()._set(default_scenario)      with mock.patch(\"taipy.core.scenario._scenario_manager._ScenarioManager._get\") as config_mock:          config_mock.return_value = default_scenario          sequences_url = url_for(\"api.sequences\")          rep = client.post(              sequences_url, json={\"scenario_id\": default_scenario.id, \"sequence_name\": \"sequence\", \"tasks\": []}          )          assert rep.status_code == 201      def test_get_all_sequences(client, default_scenario_config_list):      for ds in range(10):          with mock.patch(\"src.taipy.rest.api.resources.scenario.ScenarioList.fetch_config\") as config_mock:              config_mock.return_value = default_scenario_config_list[ds]              scenario_url = url_for(\"api.scenarios\", config_id=config_mock.name)              client.post(scenario_url)        sequences_url = url_for(\"api.sequences\")      rep = client.get(sequences_url)      assert rep.status_code == 200        results = rep.get_json()      assert len(results) == 10      @pytest.mark.xfail()  def test_execute_sequence(client, default_sequence):      # test 404      user_url = url_for(\"api.sequence_submit\", sequence_id=\"foo\")      rep = client.post(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.sequence._sequence_manager._SequenceManager._get\") as manager_mock:          manager_mock.return_value = default_sequence            # test get_sequence          rep = client.post(url_for(\"api.sequence_submit\", sequence_id=\"foo\"))          assert rep.status_code == 200 "}
{"text": "from unittest import mock    from flask import url_for      def test_get_job(client, default_job):      # test 404      user_url = url_for(\"api.job_by_id\", job_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.job._job_manager._JobManager._get\") as manager_mock:          manager_mock.return_value = default_job            # test get_job          rep = client.get(url_for(\"api.job_by_id\", job_id=\"foo\"))          assert rep.status_code == 200      def test_delete_job(client):      # test 404      user_url = url_for(\"api.job_by_id\", job_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.job._job_manager._JobManager._delete\"), mock.patch(          \"taipy.core.job._job_manager._JobManager._get\"      ):          # test get_job          rep = client.delete(url_for(\"api.job_by_id\", job_id=\"foo\"))          assert rep.status_code == 200      def test_create_job(client, default_task_config):      # without config param      jobs_url = url_for(\"api.jobs\")      rep = client.post(jobs_url)      assert rep.status_code == 400        with mock.patch(\"src.taipy.rest.api.resources.job.JobList.fetch_config\") as config_mock:          config_mock.return_value = default_task_config          jobs_url = url_for(\"api.jobs\", task_id=\"foo\")          rep = client.post(jobs_url)          assert rep.status_code == 201      def test_get_all_jobs(client, create_job_list):      jobs_url = url_for(\"api.jobs\")      rep = client.get(jobs_url)      assert rep.status_code == 200        results = rep.get_json()      assert len(results) == 10      def test_cancel_job(client, default_job):      # test 404      from taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory        _OrchestratorFactory._build_orchestrator()      _OrchestratorFactory._build_dispatcher()        user_url = url_for(\"api.job_cancel\", job_id=\"foo\")      rep = client.post(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.job._job_manager._JobManager._get\") as manager_mock:          manager_mock.return_value = default_job            # test get_job          rep = client.post(url_for(\"api.job_cancel\", job_id=\"foo\"))          assert rep.status_code == 200 "}
{"text": "from unittest import mock    from flask import url_for      def test_get_task(client, default_task):      # test 404      user_url = url_for(\"api.task_by_id\", task_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.task._task_manager._TaskManager._get\") as manager_mock:          manager_mock.return_value = default_task            # test get_task          rep = client.get(url_for(\"api.task_by_id\", task_id=\"foo\"))          assert rep.status_code == 200      def test_delete_task(client):      # test 404      user_url = url_for(\"api.task_by_id\", task_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.task._task_manager._TaskManager._delete\"), mock.patch(          \"taipy.core.task._task_manager._TaskManager._get\"      ):          # test get_task          rep = client.delete(url_for(\"api.task_by_id\", task_id=\"foo\"))          assert rep.status_code == 200      def test_create_task(client, default_task_config):      # without config param      tasks_url = url_for(\"api.tasks\")      rep = client.post(tasks_url)      assert rep.status_code == 400        # config does not exist      tasks_url = url_for(\"api.tasks\", config_id=\"foo\")      rep = client.post(tasks_url)      assert rep.status_code == 404        with mock.patch(\"src.taipy.rest.api.resources.task.TaskList.fetch_config\") as config_mock:          config_mock.return_value = default_task_config          tasks_url = url_for(\"api.tasks\", config_id=\"bar\")          rep = client.post(tasks_url)          assert rep.status_code == 201      def test_get_all_tasks(client, task_data, default_task_config_list):      for ds in range(10):          with mock.patch(\"src.taipy.rest.api.resources.task.TaskList.fetch_config\") as config_mock:              config_mock.return_value = default_task_config_list[ds]              tasks_url = url_for(\"api.tasks\", config_id=config_mock.name)              client.post(tasks_url)        rep = client.get(tasks_url)      assert rep.status_code == 200        results = rep.get_json()      assert len(results) == 10      def test_execute_task(client, default_task):      # test 404      user_url = url_for(\"api.task_submit\", task_id=\"foo\")      rep = client.post(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.task._task_manager._TaskManager._get\") as manager_mock:          manager_mock.return_value = default_task            # test get_task          rep = client.post(url_for(\"api.task_submit\", task_id=\"foo\"))          assert rep.status_code == 200 "}
{"text": "from functools import wraps  from unittest.mock import MagicMock, patch    from src.taipy.rest.api.middlewares._middleware import _middleware      def mock_enterprise_middleware(f):      @wraps(f)      def wrapper(*args, **kwargs):          return f(*args, **kwargs)        return wrapper      @patch(\"src.taipy.rest.api.middlewares._middleware._using_enterprise\")  @patch(\"src.taipy.rest.api.middlewares._middleware._enterprise_middleware\")  def test_enterprise_middleware_applied_when_enterprise_is_installed(      enterprise_middleware: MagicMock, using_enterprise: MagicMock  ):      enterprise_middleware.return_value = mock_enterprise_middleware      using_enterprise.return_value = True        @_middleware      def f():          return \"f\"        rv = f()      assert rv == \"f\"      using_enterprise.assert_called_once()      enterprise_middleware.assert_called_once()      @patch(\"src.taipy.rest.api.middlewares._middleware._using_enterprise\")  @patch(\"src.taipy.rest.api.middlewares._middleware._enterprise_middleware\")  def test_enterprise_middleware_not_applied_when_enterprise_is_not_installed(      enterprise_middleware: MagicMock, using_enterprise: MagicMock  ):      enterprise_middleware.return_value = mock_enterprise_middleware      using_enterprise.return_value = False        @_middleware      def f():          return \"f\"        rv = f()      assert rv == \"f\"      using_enterprise.assert_called_once()      enterprise_middleware.assert_not_called() "}
{"text": "from unittest import mock    import pytest  from flask import url_for      def test_get_datanode(client, default_datanode):      # test 404      user_url = url_for(\"api.datanode_by_id\", datanode_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.data._data_manager._DataManager._get\") as manager_mock:          manager_mock.return_value = default_datanode          # test get_datanode          rep = client.get(url_for(\"api.datanode_by_id\", datanode_id=\"foo\"))          assert rep.status_code == 200      def test_delete_datanode(client):      # test 404      user_url = url_for(\"api.datanode_by_id\", datanode_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.data._data_manager._DataManager._delete\"), mock.patch(          \"taipy.core.data._data_manager._DataManager._get\"      ):          # test get_datanode          rep = client.delete(url_for(\"api.datanode_by_id\", datanode_id=\"foo\"))          assert rep.status_code == 200      def test_create_datanode(client, default_datanode_config):      # without config param      datanodes_url = url_for(\"api.datanodes\")      rep = client.post(datanodes_url)      assert rep.status_code == 400        # config does not exist      datanodes_url = url_for(\"api.datanodes\", config_id=\"foo\")      rep = client.post(datanodes_url)      assert rep.status_code == 404        with mock.patch(\"src.taipy.rest.api.resources.datanode.DataNodeList.fetch_config\") as config_mock:          config_mock.return_value = default_datanode_config          datanodes_url = url_for(\"api.datanodes\", config_id=\"bar\")          rep = client.post(datanodes_url)          assert rep.status_code == 201      def test_get_all_datanodes(client, default_datanode_config_list):      for ds in range(10):          with mock.patch(\"src.taipy.rest.api.resources.datanode.DataNodeList.fetch_config\") as config_mock:              config_mock.return_value = default_datanode_config_list[ds]              datanodes_url = url_for(\"api.datanodes\", config_id=config_mock.name)              client.post(datanodes_url)        rep = client.get(datanodes_url)      assert rep.status_code == 200        results = rep.get_json()      assert len(results) == 10      def test_read_datanode(client, default_df_datanode):      with mock.patch(\"taipy.core.data._data_manager._DataManager._get\") as config_mock:          config_mock.return_value = default_df_datanode            # without operators          datanodes_url = url_for(\"api.datanode_reader\", datanode_id=\"foo\")          rep = client.get(datanodes_url, json={})          assert rep.status_code == 200            # Without operators and body          rep = client.get(datanodes_url)          assert rep.status_code == 200            # TODO: Revisit filter test          # operators = {\"operators\": [{\"key\": \"a\", \"value\": 5, \"operator\": \"LESS_THAN\"}]}          # rep = client.get(datanodes_url, json=operators)          # assert rep.status_code == 200      def test_write_datanode(client, default_datanode):      with mock.patch(\"taipy.core.data._data_manager._DataManager._get\") as config_mock:          config_mock.return_value = default_datanode          # Get DataNode          datanodes_read_url = url_for(\"api.datanode_reader\", datanode_id=default_datanode.id)          rep = client.get(datanodes_read_url, json={})          assert rep.status_code == 200          assert rep.json == {\"data\": [1, 2, 3, 4, 5, 6]}            datanodes_write_url = url_for(\"api.datanode_writer\", datanode_id=default_datanode.id)          rep = client.put(datanodes_write_url, json=[1, 2, 3])          assert rep.status_code == 200            rep = client.get(datanodes_read_url, json={})          assert rep.status_code == 200          assert rep.json == {\"data\": [1, 2, 3]} "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import json  from typing import Dict    from flask import url_for      def create_and_submit_scenario(config_id: str, client) -> Dict:      response = client.post(url_for(\"api.scenarios\", config_id=config_id))      assert response.status_code == 201        scenario = response.json.get(\"scenario\")      assert (set(scenario) - set(json.load(open(\"tests/json/expected/scenario.json\")))) == set()        response = client.post(url_for(\"api.scenario_submit\", scenario_id=scenario.get(\"id\")))      assert response.status_code == 200        return scenario      def get(url, name, client) -> Dict:      response = client.get(url)      returned_data = response.json.get(name)        assert (set(returned_data) - set(json.load(open(f\"tests/json/expected/{name}.json\")))) == set()        return returned_data      def get_assert_status(url, client, status_code) -> None:      response = client.get(url)      assert response.status_code == status_code      def get_all(url, expected_quantity, client):      response = client.get(url)        assert len(response.json) == expected_quantity      def delete(url, client):      response = client.delete(url)        assert response.status_code == 200      def test_end_to_end(client, setup_end_to_end):      # Create Scenario: Should also create all of its dependencies(sequences, tasks, datanodes, etc)      scenario = create_and_submit_scenario(\"scenario\", client)        # Get other models and verify if they return the necessary fields      cycle = get(url_for(\"api.cycle_by_id\", cycle_id=scenario.get(\"cycle\")), \"cycle\", client)      sequence = get(          url_for(\"api.sequence_by_id\", sequence_id=f\"SEQUENCE_sequence_{scenario['id']}\"),          \"sequence\",          client,      )      task = get(url_for(\"api.task_by_id\", task_id=sequence.get(\"tasks\")[0]), \"task\", client)      datanode = get(          url_for(\"api.datanode_by_id\", datanode_id=task.get(\"input_ids\")[0]),          \"datanode\",          client,      )      # Get All      get_all(url_for(\"api.scenarios\"), 1, client)      get_all(url_for(\"api.cycles\"), 1, client)      get_all(url_for(\"api.sequences\"), 1, client)      get_all(url_for(\"api.tasks\"), 2, client)      get_all(url_for(\"api.datanodes\"), 5, client)      get_all(url_for(\"api.jobs\"), 2, client)        # Delete entities      delete(url_for(\"api.cycle_by_id\", cycle_id=cycle.get(\"id\")), client)      delete(url_for(\"api.sequence_by_id\", sequence_id=sequence.get(\"id\")), client)      delete(url_for(\"api.task_by_id\", task_id=task.get(\"id\")), client)      delete(url_for(\"api.datanode_by_id\", datanode_id=datanode.get(\"id\")), client)        # Check status code      # Non-existing entities should return 404      get_assert_status(url_for(\"api.cycle_by_id\", cycle_id=9999999), client, 404)      get_assert_status(url_for(\"api.scenario_by_id\", scenario_id=9999999), client, 404)      get_assert_status(url_for(\"api.sequence_by_id\", sequence_id=9999999), client, 404)      get_assert_status(url_for(\"api.task_by_id\", task_id=9999999), client, 404)      get_assert_status(url_for(\"api.datanode_by_id\", datanode_id=9999999), client, 404)        # Check URL with and without trailing slashes      url_with_slash = url_for(\"api.scenarios\")      url_without_slash = url_for(\"api.scenarios\")[:-1]      get_all(url_with_slash, 1, client)      get_all(url_without_slash, 1, client) "}
{"text": "from unittest import mock    from flask import url_for      def test_get_cycle(client, default_cycle):      # test 404      cycle_url = url_for(\"api.cycle_by_id\", cycle_id=\"foo\")      rep = client.get(cycle_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.cycle._cycle_manager._CycleManager._get\") as manager_mock:          manager_mock.return_value = default_cycle            # test get_cycle          rep = client.get(url_for(\"api.cycle_by_id\", cycle_id=\"foo\"))          assert rep.status_code == 200      def test_delete_cycle(client):      # test 404      cycle_url = url_for(\"api.cycle_by_id\", cycle_id=\"foo\")      rep = client.get(cycle_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.cycle._cycle_manager._CycleManager._delete\"), mock.patch(          \"taipy.core.cycle._cycle_manager._CycleManager._get\"      ):          # test get_cycle          rep = client.delete(url_for(\"api.cycle_by_id\", cycle_id=\"foo\"))          assert rep.status_code == 200      def test_create_cycle(client, cycle_data):      # without config param      cycles_url = url_for(\"api.cycles\")      data = {\"bad\": \"data\"}      rep = client.post(cycles_url, json=data)      assert rep.status_code == 400        rep = client.post(cycles_url, json=cycle_data)      assert rep.status_code == 201      def test_get_all_cycles(client, create_cycle_list):      cycles_url = url_for(\"api.cycles\")      rep = client.get(cycles_url)      assert rep.status_code == 200        results = rep.get_json()      assert len(results) == 10 "}
{"text": "from unittest import mock    import pytest  from flask import url_for      def test_get_scenario(client, default_scenario):      # test 404      user_url = url_for(\"api.scenario_by_id\", scenario_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.scenario._scenario_manager._ScenarioManager._get\") as manager_mock:          manager_mock.return_value = default_scenario            # test get_scenario          rep = client.get(url_for(\"api.scenario_by_id\", scenario_id=\"foo\"))          assert rep.status_code == 200      def test_delete_scenario(client):      # test 404      user_url = url_for(\"api.scenario_by_id\", scenario_id=\"foo\")      rep = client.get(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.scenario._scenario_manager._ScenarioManager._delete\"), mock.patch(          \"taipy.core.scenario._scenario_manager._ScenarioManager._get\"      ):          # test get_scenario          rep = client.delete(url_for(\"api.scenario_by_id\", scenario_id=\"foo\"))          assert rep.status_code == 200      def test_create_scenario(client, default_scenario_config):      # without config param      scenarios_url = url_for(\"api.scenarios\")      rep = client.post(scenarios_url)      assert rep.status_code == 400        # config does not exist      scenarios_url = url_for(\"api.scenarios\", config_id=\"foo\")      rep = client.post(scenarios_url)      assert rep.status_code == 404        with mock.patch(\"src.taipy.rest.api.resources.scenario.ScenarioList.fetch_config\") as config_mock:          config_mock.return_value = default_scenario_config          scenarios_url = url_for(\"api.scenarios\", config_id=\"bar\")          rep = client.post(scenarios_url)          assert rep.status_code == 201      def test_get_all_scenarios(client, default_sequence, default_scenario_config_list):      for ds in range(10):          with mock.patch(\"src.taipy.rest.api.resources.scenario.ScenarioList.fetch_config\") as config_mock:              config_mock.return_value = default_scenario_config_list[ds]              scenarios_url = url_for(\"api.scenarios\", config_id=config_mock.name)              client.post(scenarios_url)        rep = client.get(scenarios_url)      assert rep.status_code == 200        results = rep.get_json()      assert len(results) == 10      @pytest.mark.xfail()  def test_execute_scenario(client, default_scenario):      # test 404      user_url = url_for(\"api.scenario_submit\", scenario_id=\"foo\")      rep = client.post(user_url)      assert rep.status_code == 404        with mock.patch(\"taipy.core.scenario._scenario_manager._ScenarioManager._get\") as manager_mock:          manager_mock.return_value = default_scenario            # test get_scenario          rep = client.post(url_for(\"api.scenario_submit\", scenario_id=\"foo\"))          assert rep.status_code == 200 "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "import pickle  import random  from datetime import datetime, timedelta  from typing import Any, Dict    import pandas as pd    n_predictions = 14      def forecast(model, date: datetime):      dates = [date + timedelta(days=i) for i in range(n_predictions)]      forecasts = [f + random.uniform(0, 2) for f in model.forecast(len(dates))]      days = [str(dt.date()) for dt in dates]      res = {\"Date\": days, \"Forecast\": forecasts}      return pd.DataFrame.from_dict(res)      def evaluate(cleaned: pd.DataFrame, forecasts: pd.DataFrame, date: datetime) -> Dict[str, Any]:      cleaned = cleaned[cleaned[\"Date\"].isin(forecasts[\"Date\"].tolist())]      forecasts_as_series = pd.Series(forecasts[\"Forecast\"].tolist(), name=\"Forecast\")      res = pd.concat([cleaned.reset_index(), forecasts_as_series], axis=1)      res[\"Delta\"] = abs(res[\"Forecast\"] - res[\"Value\"])        return {          \"Date\": date,          \"Dataframe\": res,          \"Mean_absolute_error\": res[\"Delta\"].mean(),          \"Relative_error\": (res[\"Delta\"].mean() * 100) / res[\"Value\"].mean(),      }      if __name__ == \"__main__\":      model = pickle.load(open(\"../my_model.p\", \"rb\"))      day = datetime(2020, 1, 25)      forecasts = forecast(model, day)        historical_temperature = pd.read_csv(\"../historical_temperature.csv\")      evaluation = evaluate(historical_temperature, forecasts, day)        print(evaluation[\"Dataframe\"])      print()      print(f'Mean absolute error : {evaluation[\"Mean_absolute_error\"]}')      print(f'Relative error in %: {evaluation[\"Relative_error\"]}') "}
{"text": "from taipy.core import Config, Frequency    from .algorithms import evaluate, forecast    model_cfg = Config.configure_data_node(\"model\", path=\"my_model.p\", storage_type=\"pickle\")    day_cfg = Config.configure_data_node(id=\"day\")  forecasts_cfg = Config.configure_data_node(id=\"forecasts\")  forecast_task_cfg = Config.configure_task(      id=\"forecast_task\",      input=[model_cfg, day_cfg],      function=forecast,      output=forecasts_cfg,  )    historical_temperature_cfg = Config.configure_data_node(      \"historical_temperature\",      storage_type=\"csv\",      path=\"historical_temperature.csv\",      has_header=True,  )  evaluation_cfg = Config.configure_data_node(\"evaluation\")  evaluate_task_cfg = Config.configure_task(      \"evaluate_task\",      input=[historical_temperature_cfg, forecasts_cfg, day_cfg],      function=evaluate,      output=evaluation_cfg,  )    scenario_cfg = Config.configure_scenario(\"scenario\", [forecast_task_cfg, evaluate_task_cfg], frequency=Frequency.DAILY)  scenario_cfg.add_sequences({\"sequence\": [forecast_task_cfg, evaluate_task_cfg]}) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from importlib.util import find_spec    if find_spec(\"taipy\"):      if find_spec(\"taipy.config\"):          from taipy.config._init import *  # type: ignore        if find_spec(\"taipy.gui\"):          from taipy.gui._init import *  # type: ignore        if find_spec(\"taipy.core\"):          from taipy.core._init import *  # type: ignore        if find_spec(\"taipy.rest\"):          from taipy.rest._init import *  # type: ignore        if find_spec(\"taipy.gui_core\"):          from taipy.gui_core._init import *  # type: ignore        if find_spec(\"taipy.enterprise\"):          from taipy.enterprise._init import *  # type: ignore        if find_spec(\"taipy._run\"):          from taipy._run import _run as run  # type: ignore "}
{"text": "import json  import os      def _get_version():      with open(f\"{os.path.dirname(os.path.abspath(__file__))}{os.sep}version.json\") as version_file:          version = json.load(version_file)          version_string = f'{version.get(\"major\", 0)}.{version.get(\"minor\", 0)}.{version.get(\"patch\", 0)}'          if vext := version.get(\"ext\"):              version_string = f\"{version_string}.{vext}\"      return version_string "}
{"text": "from .rest import Rest "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License.  from taipy.config import Config    from .app import create_app as _create_app      class Rest:      \"\"\"      Runnable Rest application serving REST APIs on top of Taipy Core functionalities.      \"\"\"        def __init__(self):          \"\"\"          Initialize a REST API server.            A Flask application is instantiated and configured using three parameters from the global          config.              - Config.global_config.testing (bool): Run the application on testing mode.              - Config.global_config.env (Optional[str]): The application environment.              - Config.global_config.secret_key (Optional[str]): Application server secret key.            However, editing these parameters is only recommended for advanced users. Indeed, the default behavior of the          REST server without any required configuration satisfies all the standard and basic needs.          \"\"\"          self._app = _create_app(Config.global_config.testing or False, Config.global_config.env,                                  Config.global_config.secret_key)        def run(self, **kwargs):          \"\"\"          Start a REST API server. This method is blocking.            Parameters:              **kwargs : Options to provide to the application server.          \"\"\"          self._app.run(**kwargs) "}
{"text": "\"\"\"# Taipy Rest    The Taipy Rest package exposes the Runnable `Rest^` service to provide REST APIs on top of Taipy Core. (more details  on Taipy Core functionalities in the [user manual](../../../manuals/core/)).    Once the `Rest^` service runs, users can call REST APIs to create, read, update, submit and remove Taipy entities  (including cycles, scenarios, sequences, tasks, jobs, and data nodes). It is handy when it comes to integrating a  Taipy application in a more complex IT ecosystem.    Please refer to [REST API](../../reference_rest/) page to get the exhaustive list of available APIs.\"\"\"    from ._init import *  from .version import _get_version    __version__ = _get_version() "}
{"text": "\"\"\"Extensions registry    All extensions here are used as singletons and  initialized in application factory  \"\"\"    from .commons.apispec import APISpecExt    apispec = APISpecExt()"}
{"text": "import os    from flask import Flask    from . import api  from .commons.encoder import _CustomEncoder  from .extensions import apispec      def create_app(testing=False, flask_env=None, secret_key=None):      \"\"\"Application factory, used to create application\"\"\"      app = Flask(__name__)      app.config.update(          ENV=os.getenv(\"FLASK_ENV\", flask_env),          TESTING=os.getenv(\"TESTING\", testing),          SECRET_KEY=os.getenv(\"SECRET_KEY\", secret_key),      )      app.url_map.strict_slashes = False      app.config[\"RESTFUL_JSON\"] = {\"cls\": _CustomEncoder}        configure_apispec(app)      register_blueprints(app)      with app.app_context():          api.views.register_views()        return app      def configure_apispec(app):      \"\"\"Configure APISpec for swagger support\"\"\"      apispec.init_app(app)        apispec.spec.components.schema(          \"PaginatedResult\",          {              \"properties\": {                  \"total\": {\"type\": \"integer\"},                  \"pages\": {\"type\": \"integer\"},                  \"next\": {\"type\": \"string\"},                  \"prev\": {\"type\": \"string\"},              }          },      )      def register_blueprints(app):      \"\"\"Register all blueprints for application\"\"\"      app.register_blueprint(api.views.blueprint) "}
{"text": "from taipy.core.cycle._cycle_converter import _CycleConverter  from taipy.core.data._data_converter import _DataNodeConverter  from taipy.core.scenario._scenario_converter import _ScenarioConverter  from taipy.core.sequence._sequence_converter import _SequenceConverter  from taipy.core.task._task_converter import _TaskConverter    entity_to_models = {      \"scenario\": _ScenarioConverter._entity_to_model,      \"sequence\": _SequenceConverter._entity_to_model,      \"task\": _TaskConverter._entity_to_model,      \"data\": _DataNodeConverter._entity_to_model,      \"cycle\": _CycleConverter._entity_to_model,  }      def _to_model(repository, entity, **kwargs):      return entity_to_models[repository](entity) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from apispec import APISpec  from apispec.exceptions import APISpecError  from apispec.ext.marshmallow import MarshmallowPlugin  from apispec_webframeworks.flask import FlaskPlugin  from flask import Blueprint, jsonify, render_template      class FlaskRestfulPlugin(FlaskPlugin):      \"\"\"Small plugin override to handle flask-restful resources\"\"\"        @staticmethod      def _rule_for_view(view, app=None):          view_funcs = app.view_functions          endpoint = None            for ept, view_func in view_funcs.items():              if hasattr(view_func, \"view_class\"):                  view_func = view_func.view_class                if view_func == view:                  endpoint = ept            if not endpoint:              raise APISpecError(\"Could not find endpoint for view {0}\".format(view))            # WARNING: Assume 1 rule per view function for now          rule = app.url_map._rules_by_endpoint[endpoint][0]          return rule      class APISpecExt:      \"\"\"Very simple and small extension to use apispec with this API as a flask extension\"\"\"        def __init__(self, app=None, **kwargs):          self.spec = None            if app is not None:              self.init_app(app, **kwargs)        def init_app(self, app, **kwargs):          app.config.setdefault(\"APISPEC_TITLE\", \"Taipy Rest\")          app.config.setdefault(\"APISPEC_VERSION\", \"1.0.0\")          app.config.setdefault(\"OPENAPI_VERSION\", \"3.0.2\")          app.config.setdefault(\"SWAGGER_JSON_URL\", \"/swagger.json\")          app.config.setdefault(\"SWAGGER_UI_URL\", \"/swagger-ui\")          app.config.setdefault(\"OPENAPI_YAML_URL\", \"/openapi.yaml\")          app.config.setdefault(\"REDOC_UI_URL\", \"/redoc-ui\")          app.config.setdefault(\"SWAGGER_URL_PREFIX\", None)            self.spec = APISpec(              title=app.config[\"APISPEC_TITLE\"],              version=app.config[\"APISPEC_VERSION\"],              openapi_version=app.config[\"OPENAPI_VERSION\"],              plugins=[MarshmallowPlugin(), FlaskRestfulPlugin()],              **kwargs          )            blueprint = Blueprint(              \"swagger\",              __name__,              template_folder=\"./templates\",              url_prefix=app.config[\"SWAGGER_URL_PREFIX\"],          )            blueprint.add_url_rule(app.config[\"SWAGGER_JSON_URL\"], \"swagger_json\", self.swagger_json)          blueprint.add_url_rule(app.config[\"SWAGGER_UI_URL\"], \"swagger_ui\", self.swagger_ui)          blueprint.add_url_rule(app.config[\"OPENAPI_YAML_URL\"], \"openapi_yaml\", self.openapi_yaml)          blueprint.add_url_rule(app.config[\"REDOC_UI_URL\"], \"redoc_ui\", self.redoc_ui)            app.register_blueprint(blueprint)        def swagger_json(self):          return jsonify(self.spec.to_dict())        def swagger_ui(self):          return render_template(\"swagger.j2\")        def openapi_yaml(self):          # Manually inject ReDoc's Authentication legend, then remove it          self.spec.tag(              {                  \"name\": \"authentication\",                  \"x-displayName\": \"Authentication\",                  \"description\": \"<SecurityDefinitions />\",              }          )          redoc_spec = self.spec.to_yaml()          self.spec._tags.pop(0)          return redoc_spec        def redoc_ui(self):          return render_template(\"redoc.j2\") "}
{"text": "import json  from typing import Any, Union  from datetime import datetime  from enum import Enum        Json = Union[dict, list, str, int, float, bool, None]    class _CustomEncoder(json.JSONEncoder):      def default(self, o: Any) -> Json:          if isinstance(o, Enum):              result = o.value          elif isinstance(o, datetime):              result = {\"__type__\": \"Datetime\", \"__value__\": o.isoformat()}          else:              result = json.JSONEncoder.default(self, o)          return result "}
{"text": "\"\"\"Simple helper to paginate query  \"\"\"  from flask import request, url_for    DEFAULT_PAGE_SIZE = 50  DEFAULT_PAGE_NUMBER = 1      def extract_pagination(page=None, per_page=None, **request_args):      page = int(page) if page is not None else DEFAULT_PAGE_NUMBER      per_page = int(per_page) if per_page is not None else DEFAULT_PAGE_SIZE      return page, per_page, request_args      def paginate(query, schema):      page, per_page, other_request_args = extract_pagination(**request.args)      page_obj = query.paginate(page=page, per_page=per_page)      next_ = url_for(          request.endpoint,          page=page_obj.next_num if page_obj.has_next else page_obj.page,          per_page=per_page,          **other_request_args,          **request.view_args      )      prev = url_for(          request.endpoint,          page=page_obj.prev_num if page_obj.has_prev else page_obj.page,          per_page=per_page,          **other_request_args,          **request.view_args      )        return {          \"total\": page_obj.total,          \"pages\": page_obj.pages,          \"next\": next_,          \"prev\": prev,          \"results\": schema.dump(page_obj.items),      } "}
{"text": "from . import error_handler, views    __all__ = [\"views\", \"error_handler\"] "}
{"text": "from flask import jsonify  from marshmallow import ValidationError    from taipy.core.exceptions.exceptions import (      NonExistingCycle,      NonExistingDataNode,      NonExistingDataNodeConfig,      NonExistingJob,      NonExistingScenario,      NonExistingScenarioConfig,      NonExistingSequence,      NonExistingSequenceConfig,      NonExistingTask,      NonExistingTaskConfig,  )    from .exceptions.exceptions import ConfigIdMissingException, ScenarioIdMissingException, SequenceNameMissingException  from .views import blueprint      def _create_404(e):      return {\"message\": e.message}, 404      @blueprint.errorhandler(ValidationError)  def handle_marshmallow_error(e):      \"\"\"Return json error for marshmallow validation errors.        This will avoid having to try/catch ValidationErrors in all endpoints, returning      correct JSON response with associated HTTP 400 Status (https://tools.ietf.org/html/rfc7231#section-6.5.1)      \"\"\"      return jsonify(e.messages), 400      @blueprint.errorhandler(ConfigIdMissingException)  def handle_config_id_missing_exception(e):      return jsonify({\"message\": e.message}), 400      @blueprint.errorhandler(ScenarioIdMissingException)  def handle_scenario_id_missing_exception(e):      return jsonify({\"message\": e.message}), 400      @blueprint.errorhandler(SequenceNameMissingException)  def handle_sequence_name_missing_exception(e):      return jsonify({\"message\": e.message}), 400      @blueprint.errorhandler(NonExistingDataNode)  def handle_data_node_not_found(e):      return _create_404(e)      @blueprint.errorhandler(NonExistingDataNodeConfig)  def handle_data_node_config_not_found(e):      return _create_404(e)      @blueprint.errorhandler(NonExistingCycle)  def handle_cycle_not_found(e):      return _create_404(e)      @blueprint.errorhandler(NonExistingJob)  def handle_job_not_found(e):      return _create_404(e)      @blueprint.errorhandler(NonExistingSequence)  def handle_sequence_not_found(e):      return _create_404(e)      @blueprint.errorhandler(NonExistingSequenceConfig)  def handle_sequence_config_not_found(e):      return _create_404(e)      @blueprint.errorhandler(NonExistingScenario)  def handle_scenario_not_found(e):      return _create_404(e)      @blueprint.errorhandler(NonExistingScenarioConfig)  def handle_scenario_config_not_found(e):      return _create_404(e)      @blueprint.errorhandler(NonExistingTask)  def handle_task_not_found(e):      return _create_404(e)      @blueprint.errorhandler(NonExistingTaskConfig)  def handle_task_config_not_found(e):      return _create_404(e) "}
{"text": "from flask import Blueprint, current_app  from flask_restful import Api    from taipy.core.common._utils import _load_fct  from taipy.logger._taipy_logger import _TaipyLogger    from ..extensions import apispec  from .middlewares._middleware import _using_enterprise  from .resources import (      CycleList,      CycleResource,      DataNodeList,      DataNodeReader,      DataNodeResource,      DataNodeWriter,      JobExecutor,      JobList,      JobResource,      ScenarioExecutor,      ScenarioList,      ScenarioResource,      SequenceExecutor,      SequenceList,      SequenceResource,      TaskExecutor,      TaskList,      TaskResource,  )  from .schemas import CycleSchema, DataNodeSchema, JobSchema, ScenarioSchema, SequenceSchema, TaskSchema    _logger = _TaipyLogger._get_logger()      blueprint = Blueprint(\"api\", __name__, url_prefix=\"/api/v1\")    api = Api(blueprint)    api.add_resource(      DataNodeResource,      \"/datanodes/<string:datanode_id>/\",      endpoint=\"datanode_by_id\",      resource_class_kwargs={\"logger\": _logger},  )    api.add_resource(      DataNodeReader,      \"/datanodes/<string:datanode_id>/read/\",      endpoint=\"datanode_reader\",      resource_class_kwargs={\"logger\": _logger},  )    api.add_resource(      DataNodeWriter,      \"/datanodes/<string:datanode_id>/write/\",      endpoint=\"datanode_writer\",      resource_class_kwargs={\"logger\": _logger},  )    api.add_resource(      DataNodeList,      \"/datanodes/\",      endpoint=\"datanodes\",      resource_class_kwargs={\"logger\": _logger},  )    api.add_resource(      TaskResource,      \"/tasks/<string:task_id>/\",      endpoint=\"task_by_id\",      resource_class_kwargs={\"logger\": _logger},  )    api.add_resource(TaskList, \"/tasks/\", endpoint=\"tasks\", resource_class_kwargs={\"logger\": _logger})  api.add_resource(      TaskExecutor,      \"/tasks/submit/<string:task_id>/\",      endpoint=\"task_submit\",      resource_class_kwargs={\"logger\": _logger},  )    api.add_resource(      SequenceResource,      \"/sequences/<string:sequence_id>/\",      endpoint=\"sequence_by_id\",      resource_class_kwargs={\"logger\": _logger},  )  api.add_resource(      SequenceList,      \"/sequences/\",      endpoint=\"sequences\",      resource_class_kwargs={\"logger\": _logger},  )  api.add_resource(      SequenceExecutor,      \"/sequences/submit/<string:sequence_id>/\",      endpoint=\"sequence_submit\",      resource_class_kwargs={\"logger\": _logger},  )    api.add_resource(      ScenarioResource,      \"/scenarios/<string:scenario_id>/\",      endpoint=\"scenario_by_id\",      resource_class_kwargs={\"logger\": _logger},  )  api.add_resource(      ScenarioList,      \"/scenarios/\",      endpoint=\"scenarios\",      resource_class_kwargs={\"logger\": _logger},  )  api.add_resource(      ScenarioExecutor,      \"/scenarios/submit/<string:scenario_id>/\",      endpoint=\"scenario_submit\",      resource_class_kwargs={\"logger\": _logger},  )    api.add_resource(      CycleResource,      \"/cycles/<string:cycle_id>/\",      endpoint=\"cycle_by_id\",      resource_class_kwargs={\"logger\": _logger},  )  api.add_resource(      CycleList,      \"/cycles/\",      endpoint=\"cycles\",      resource_class_kwargs={\"logger\": _logger},  )    api.add_resource(      JobResource,      \"/jobs/<string:job_id>/\",      endpoint=\"job_by_id\",      resource_class_kwargs={\"logger\": _logger},  )  api.add_resource(JobList, \"/jobs/\", endpoint=\"jobs\", resource_class_kwargs={\"logger\": _logger})  api.add_resource(      JobExecutor,      \"/jobs/cancel/<string:job_id>/\",      endpoint=\"job_cancel\",      resource_class_kwargs={\"logger\": _logger},  )      def load_enterprise_resources(api: Api):      \"\"\"      Load enterprise resources.      \"\"\"        if not _using_enterprise():          return      load_resources = _load_fct(\"taipy.enterprise.rest.api.views\", \"_load_resources\")      load_resources(api)      load_enterprise_resources(api)      def register_views():      apispec.spec.components.schema(\"DataNodeSchema\", schema=DataNodeSchema)      apispec.spec.path(view=DataNodeResource, app=current_app)      apispec.spec.path(view=DataNodeList, app=current_app)      apispec.spec.path(view=DataNodeReader, app=current_app)      apispec.spec.path(view=DataNodeWriter, app=current_app)        apispec.spec.components.schema(\"TaskSchema\", schema=TaskSchema)      apispec.spec.path(view=TaskResource, app=current_app)      apispec.spec.path(view=TaskList, app=current_app)      apispec.spec.path(view=TaskExecutor, app=current_app)        apispec.spec.components.schema(\"SequenceSchema\", schema=SequenceSchema)      apispec.spec.path(view=SequenceResource, app=current_app)      apispec.spec.path(view=SequenceList, app=current_app)      apispec.spec.path(view=SequenceExecutor, app=current_app)        apispec.spec.components.schema(\"ScenarioSchema\", schema=ScenarioSchema)      apispec.spec.path(view=ScenarioResource, app=current_app)      apispec.spec.path(view=ScenarioList, app=current_app)      apispec.spec.path(view=ScenarioExecutor, app=current_app)        apispec.spec.components.schema(\"CycleSchema\", schema=CycleSchema)      apispec.spec.path(view=CycleResource, app=current_app)      apispec.spec.path(view=CycleList, app=current_app)        apispec.spec.components.schema(\"JobSchema\", schema=JobSchema)      apispec.spec.path(view=JobResource, app=current_app)      apispec.spec.path(view=JobList, app=current_app)      apispec.spec.path(view=JobExecutor, app=current_app)        apispec.spec.components.schema(          \"Any\",          {              \"description\": \"Any value\",              \"nullable\": True,          },      )        if _using_enterprise():          _register_views = _load_fct(\"taipy.enterprise.rest.api.views\", \"_register_views\")          _register_views(apispec) "}
{"text": "from .cycle import CycleList, CycleResource  from .datanode import DataNodeList, DataNodeReader, DataNodeResource, DataNodeWriter  from .job import JobExecutor, JobList, JobResource  from .scenario import ScenarioExecutor, ScenarioList, ScenarioResource  from .sequence import SequenceExecutor, SequenceList, SequenceResource  from .task import TaskExecutor, TaskList, TaskResource    __all__ = [      \"DataNodeResource\",      \"DataNodeList\",      \"DataNodeReader\",      \"DataNodeWriter\",      \"TaskList\",      \"TaskResource\",      \"TaskExecutor\",      \"SequenceList\",      \"SequenceResource\",      \"SequenceExecutor\",      \"ScenarioList\",      \"ScenarioResource\",      \"ScenarioExecutor\",      \"CycleResource\",      \"CycleList\",      \"JobResource\",      \"JobList\",      \"JobExecutor\",  ] "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "from functools import wraps  from importlib import util    from taipy.core.common._utils import _load_fct      def _middleware(f):      @wraps(f)      def wrapper(*args, **kwargs):          if _using_enterprise():              return _enterprise_middleware()(f)(*args, **kwargs)          else:              return f(*args, **kwargs)        return wrapper      def _using_enterprise():      return util.find_spec(\"taipy.enterprise\") is not None      def _enterprise_middleware():      return _load_fct(\"taipy.enterprise.rest.api.middlewares._middleware\", \"_middleware\") "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  # specific language governing permissions and limitations under the License. "}
{"text": "  class ConfigIdMissingException(Exception):      def __init__(self):          self.message = \"Config id is missing.\"      class ScenarioIdMissingException(Exception):      def __init__(self):          self.message = \"Scenario id is missing.\"      class SequenceNameMissingException(Exception):      def __init__(self):          self.message = \"Sequence name is missing.\" "}
{"text": "from marshmallow import Schema, fields      class CycleSchema(Schema):      name = fields.String()      frequency = fields.String()      properties = fields.Dict()      creation_date = fields.String()      start_date = fields.String()      end_date = fields.String()      class CycleResponseSchema(CycleSchema):      id = fields.String() "}
{"text": "from marshmallow import Schema, fields      class TaskSchema(Schema):        config_id = fields.String()      id = fields.String()      owner_id = fields.String()      parent_ids = fields.List(fields.String)      input_ids = fields.List(fields.String)      function_name = fields.String()      function_module = fields.String()      output_ids = fields.List(fields.String)      version = fields.String() "}
{"text": "from marshmallow import Schema, fields      class CallableSchema(Schema):      fct_name = fields.String()      fct_module = fields.String()      class JobSchema(Schema):      id = fields.String()      task_id = fields.String()      status = fields.String()      force = fields.Boolean()      creation_date = fields.String()      subscribers = fields.Nested(CallableSchema)      stacktrace = fields.List(fields.String) "}
{"text": "from marshmallow import Schema, fields      class SequenceSchema(Schema):      owner_id = fields.String()      parent_ids = fields.List(fields.String)      tasks = fields.List(fields.String)      version = fields.String()      properties = fields.Dict()      class SequenceResponseSchema(SequenceSchema):      id = fields.String()      subscribers = fields.List(fields.Dict) "}
{"text": "from .cycle import CycleResponseSchema, CycleSchema  from .datanode import (      CSVDataNodeConfigSchema,      DataNodeConfigSchema,      DataNodeFilterSchema,      DataNodeSchema,      ExcelDataNodeConfigSchema,      GenericDataNodeConfigSchema,      InMemoryDataNodeConfigSchema,      JSONDataNodeConfigSchema,      MongoCollectionDataNodeConfigSchema,      PickleDataNodeConfigSchema,      SQLDataNodeConfigSchema,      SQLTableDataNodeConfigSchema,  )  from .job import JobSchema  from .scenario import ScenarioResponseSchema, ScenarioSchema  from .sequence import SequenceResponseSchema, SequenceSchema  from .task import TaskSchema    __all__ = [      \"DataNodeSchema\",      \"DataNodeFilterSchema\",      \"TaskSchema\",      \"SequenceSchema\",      \"SequenceResponseSchema\",      \"ScenarioSchema\",      \"ScenarioResponseSchema\",      \"CycleSchema\",      \"CycleResponseSchema\",      \"JobSchema\",  ] "}
{"text": "from marshmallow import Schema, fields, pre_dump      class DataNodeSchema(Schema):      config_id = fields.String()      scope = fields.String()      id = fields.String()      storage_type = fields.String()      name = fields.String()      owner_id = fields.String()      parent_ids = fields.List(fields.String)      last_edit_date = fields.String()      job_ids = fields.List(fields.String)      version = fields.String()      cacheable = fields.Boolean()      validity_days = fields.Float()      validity_seconds = fields.Float()      edit_in_progress = fields.Boolean()      properties = fields.Dict()      class DataNodeConfigSchema(Schema):      name = fields.String()      storage_type = fields.String()      scope = fields.Integer()      cacheable = fields.Boolean()        @pre_dump      def serialize_scope(self, obj, **kwargs):          obj.scope = obj.scope.value          return obj      class CSVDataNodeConfigSchema(DataNodeConfigSchema):      path = fields.String()      default_path = fields.String()      has_header = fields.Boolean()      class InMemoryDataNodeConfigSchema(DataNodeConfigSchema):      default_data = fields.Inferred()      class PickleDataNodeConfigSchema(DataNodeConfigSchema):      path = fields.String()      default_path = fields.String()      default_data = fields.Inferred()      class SQLTableDataNodeConfigSchema(DataNodeConfigSchema):      db_name = fields.String()      table_name = fields.String()      class SQLDataNodeConfigSchema(DataNodeConfigSchema):      db_name = fields.String()      read_query = fields.String()      write_query = fields.List(fields.String())      class MongoCollectionDataNodeConfigSchema(DataNodeConfigSchema):      db_name = fields.String()      collection_name = fields.String()      class ExcelDataNodeConfigSchema(DataNodeConfigSchema):      path = fields.String()      default_path = fields.String()      has_header = fields.Boolean()      sheet_name = fields.String()      class GenericDataNodeConfigSchema(DataNodeConfigSchema):      pass      class JSONDataNodeConfigSchema(DataNodeConfigSchema):      path = fields.String()      default_path = fields.String()      class OperatorSchema(Schema):      key = fields.String()      value = fields.Inferred()      operator = fields.String()      class DataNodeFilterSchema(DataNodeConfigSchema):      operators = fields.List(fields.Nested(OperatorSchema))      join_operator = fields.String(default=\"AND\") "}
{"text": "from marshmallow import Schema, fields      class ScenarioSchema(Schema):      sequences = fields.Dict()      properties = fields.Dict()      primary_scenario = fields.Boolean(default=False)      tags = fields.List(fields.String)      version = fields.String()      class ScenarioResponseSchema(ScenarioSchema):      id = fields.String()      subscribers = fields.List(fields.Dict)      cycle = fields.String()      creation_date = fields.String() "}
{"text": "from importlib import util  import inspect  import os    if util.find_spec(\"taipy\") and util.find_spec(\"taipy.gui\"):      from taipy.gui import Gui        taipy_path = f\"{os.path.dirname(os.path.dirname(inspect.getfile(Gui)))}\"      potential_file_paths = [          f\"{taipy_path}{os.sep}gui{os.sep}viselements.json\",          f\"{taipy_path}{os.sep}gui_core{os.sep}viselements.json\",      ]      if potential_file_paths := [          path for path in potential_file_paths if os.path.exists(path)      ]:          print(f\"Path: {';;;'.join(potential_file_paths)}\")      else:          print(\"Visual element descriptor files not found in taipy-gui package\")  else:      print(\"taipy-gui package is not installed within the selected python environment\") "}
{"text": "import taipy as tp  import pandas as pd  from taipy import Config  from taipy.gui import Gui, Markdown, notify    Config.configure_global_app(clean_entities_enabled=True)  tp.clean_all_entities()    input_text_cfg = Config.configure_data_node(id=\"input_text\")  text_length_cfg = Config.configure_data_node(id=\"text_length\")    count_characters_cfg = Config.configure_task(id=\"count_characters\", function=len, input=input_text_cfg, output=text_length_cfg)    scenario_cfg = Config.configure_scenario_from_tasks(id=\"count_characters\", task_configs=[count_characters_cfg])    scenario_list = tp.get_scenarios()  input_text = \"\"  main_md = Markdown(\"\"\"  # Taipy Character Counter    Enter Text:    <|{input_text}|input|>    <|Submit|button|on_action=submit|>    ----------    Past Results:    <|{create_results_table(scenario_list)}|table|width=fit-content|>  \"\"\")    def submit(state):      scenario = tp.create_scenario(scenario_cfg)      scenario.input_text.write(state.input_text)            state.input_text = \"\"            tp.submit(scenario, wait=True)      notify(state, \"S\", \"Submitted!\")        state.scenario_list = tp.get_scenarios()        def create_results_table(scenario_list):      table = [(s.id, s.input_text.read(), s.text_length.read()) for s in scenario_list]      df = pd.DataFrame(table, columns=[\"id\", \"input_text\", \"text_length\"])      print(df)      return df    tp.Core().run()  gui = Gui(main_md)  gui.run(run_browser=False) "}
{"text": "import json      def add_line(source, line, step):        line = line.replace('Getting Started with Taipy', 'Getting Started with Taipy on Notebooks')      line = line.replace('(../src/', '(https://docs.taipy.io/en/latest/getting_started/src/')      line = line.replace('(dataset.csv)', '(https://docs.taipy.io/en/latest/getting_started/step_01/dataset.csv)')        if line.startswith('!['):          if step != 'index':              line = line.replace('(', '(https://docs.taipy.io/en/latest/getting_started/' + step + '/')          else:              line = line.replace('(', '(https://docs.taipy.io/en/latest/getting_started/')            # conversion of Markdown image to HTML          img_src = line.split('](')[1].split(')')[0]          width = line.split('](')[1].split(')')[1].split(' ')[1]            source.append('<div align=\"center\">\\n')          source.append(f' <img src={img_src} {width}>\\n')          source.append('</div>\\n')        elif step == 'step_00' and line.startswith('Gui(page='):            source.append('\\n')          source.append('Gui(\"# Getting Started with Taipy\").run(dark_mode=False)\\n')        elif line.startswith('Gui(page=') and step != 'step_00':          search_for_md = line.split(')')          name_of_md = search_for_md[0][9:]            source.append(f'gui = Gui({name_of_md})\\n')          source.append(f'gui.run()\\n')        elif step == 'step_00' and line.startswith('from taipy'):          source.append(\"from taipy.gui import Gui, Markdown\\n\")      elif 'Notebook' in line and 'step' in step:          pass      else:          source.append(line + '\\n')        return source      def detect_new_cell(notebook, source, cell, line, execution_count, force_creation=False):      if line.startswith('```python') or line.startswith('```') and cell == 'code' or force_creation:          source = source[:-1]            if cell == 'code':              notebook['cells'].append({                  \"cell_type\": \"code\",                  \"metadata\": {},                  \"outputs\": [],                  \"execution_count\": execution_count,                  \"source\": source              })              cell = 'markdown'              execution_count += 1          else:              notebook['cells'].append({                  \"cell_type\": \"markdown\",                  \"metadata\": {},                  \"source\": source              })              cell = 'code'            source = []        return cell, source, notebook, execution_count      def create_introduction(notebook, execution_count):      with open('index.md', 'r') as f:          text = f.read()        split_text = text.split('\\n')      source = []        for line in split_text:          if not line.startswith('``` console'):              add_line(source, line, 'index')          else:              break        notebook['cells'].append({          \"cell_type\": \"markdown\",          \"metadata\": {},          \"source\": source      })        notebook['cells'].append({          \"cell_type\": \"code\",          \"metadata\": {},          \"outputs\": [],          \"execution_count\": execution_count,          \"source\": ['# !pip install taipy\\n',                     '# !pip install scikit-learn\\n',                     '# !pip install statsmodels']      })        notebook['cells'].append({          \"cell_type\": \"markdown\",          \"metadata\": {},          \"source\": ['## Using Notebooks\\n',]      })        execution_count += 1      return notebook, execution_count      def create_steps(notebook, execution_count):      steps = ['step_0' + str(i) for i in range(0, 10)] + ['step_10', 'step_11', 'step_12']      source = []        for step in steps:          if source != []:              cell, source, notebook, execution_count = detect_new_cell(notebook,                                                                        source,                                                                        cell,                                                                        line,                                                                        execution_count,                                                                        force_creation=True)            with open(step + '/ReadMe.md', 'r') as f:              text = f.read()            split_text = text.split('\\n')          cell = \"markdown\"            for line in split_text:              add_line(source, line, step)              cell, source, notebook, execution_count = detect_new_cell(notebook, source, cell, line, execution_count)        return notebook, execution_count      if __name__ == '__main__':      notebook = {          \"cells\": [],          \"metadata\": {              \"language_info\": {                  \"codemirror_mode\": {                      \"name\": \"ipython\",                      \"version\": 3                  },                  \"file_extension\": \".py\",                  \"mimetype\": \"text/x-python\",                  \"name\": \"python\",                  \"nbconvert_exporter\": \"python\",                  \"pygments_lexer\": \"ipython3\"              },              \"orig_nbformat\": 4          },          \"nbformat\": 4,          \"nbformat_minor\": 2      }        execution_count = 0        notebook, execution_count = create_introduction(notebook, execution_count)      notebook, execution_count = create_steps(notebook, execution_count)        with open('getting_started.ipynb', 'w', encoding='utf-8') as f:          json.dump(notebook, f, indent=2) "}
{"text": "from step_08 import *    # Get all the scenarios already created  all_scenarios = tp.get_scenarios()    # Delete the scenarios that don't have a name attribute  # All the scenarios of the previous steps do not have an associated name so they will be deleted,  # this will not be the case for those created by this step  [tp.delete(scenario.id) for scenario in all_scenarios if scenario.name is None]    # Initial variable for the scenario selector  # The list of possible values (lov) for the scenario selector is a list of tuples (scenario_id, scenario_name),  # but the selected_scenario is just used to retrieve the scenario id and what gets displayed is the name of the scenario.  scenario_selector = [(scenario.id, scenario.name) for scenario in tp.get_scenarios()]  selected_scenario = None    scenario_manager_page = page + \"\"\"  # Create your scenario    **Prediction date**\\n\\n <|{day}|date|not with_time|>    **Max capacity**\\n\\n <|{max_capacity}|number|>    **Number of predictions**\\n\\n<|{n_predictions}|number|>    <|Create new scenario|button|on_action=create_scenario|>    ## Scenario   <|{selected_scenario}|selector|lov={scenario_selector}|dropdown|>    ## Display the pipeline  <|{selected_pipeline}|selector|lov={pipeline_selector}|>    <|{predictions_dataset}|chart|x=Date|y[1]=Historical values|type[1]=bar|y[2]=Predicted values|type[2]=scatter|height=80%|width=100%|>  \"\"\"      def create_name_for_scenario(state) -> str:      name = f\"Scenario ({state.day.strftime('%A, %d %b')}; {state.max_capacity}; {state.n_predictions})\"        # Change the name if it is the same as some scenarios      if name in [s[1] for s in state.scenario_selector]:          name += f\" ({len(state.scenario_selector)})\"      return name      # Change the create_scenario function in order to change the default parameters  # and allow the creation of multiple scenarios  def create_scenario(state):      print(\"Execution of scenario...\")      # Extra information for the scenario      creation_date = state.day      name = create_name_for_scenario(state)      # Create a scenario      scenario = tp.create_scenario(scenario_cfg, creation_date=creation_date, name=name)        state.selected_scenario = (scenario.id, name)      # Submit the scenario that is currently selected      submit_scenario(state)      def submit_scenario(state):      print(\"Submitting scenario...\")      # Get the currently selected scenario      scenario = tp.get(state.selected_scenario[0])        # Conversion to the right format (change?)      day = dt.datetime(state.day.year, state.day.month, state.day.day)        # Change the default parameters by writing in the Data Nodes      scenario.day.write(day)      scenario.n_predictions.write(int(state.n_predictions))      scenario.max_capacity.write(int(state.max_capacity))      scenario.creation_date = state.day        # Execute the scenario      tp.submit(scenario)        # Update the scenario selector and the scenario that is currently selected      update_scenario_selector(state, scenario)  # change list to scenario        # Update the chart directly      update_chart(state)      def update_scenario_selector(state, scenario):      print(\"Updating scenario selector...\")      # Update the scenario selector      state.scenario_selector += [(scenario.id, scenario.name)]      def update_chart(state):      # Now, the selected_scenario comes from the state, it is interactive      scenario = tp.get(state.selected_scenario[0])      pipeline = scenario.pipelines[state.selected_pipeline]      update_predictions_dataset(state, pipeline)      def on_change(state, var_name: str, var_value):      if var_name == \"n_week\":          # Update the dataset when the slider is moved          state.dataset_week = dataset[dataset[\"Date\"].dt.isocalendar().week == var_value]        elif var_name == \"selected_pipeline\" or var_name == \"selected_scenario\":          # Update the chart when the scenario or the pipeline is changed          # Check if we can read the data node to update the chart          if tp.get(state.selected_scenario[0]).predictions.read() is not None:              update_chart(state)      if __name__ == \"__main__\":      tp.Core().run()      Gui(page=scenario_manager_page).run(dark_mode=False) "}
{"text": "from step_07 import *    # Initial variables  ## Initial variables for the scenario     day = dt.datetime(2021, 7, 26)  n_predictions = 40  max_capacity = 200    page_scenario_manager = page + \"\"\"  # Change your scenario    **Prediction date**\\n\\n <|{day}|date|not with_time|>    **Max capacity**\\n\\n <|{max_capacity}|number|>    **Number of predictions**\\n\\n<|{n_predictions}|number|>    <|Save changes|button|on_action={submit_scenario}|>    Select the pipeline  <|{selected_pipeline}|selector|lov={pipeline_selector}|> <|Update chart|button|on_action={update_chart}|>    <|{predictions_dataset}|chart|x=Date|y[1]=Historical values|type[1]=bar|y[2]=Predicted values|type[2]=scatter|height=80%|width=100%|>  \"\"\"      def create_scenario():      global selected_scenario        print(\"Creating scenario...\")      scenario = tp.create_scenario(scenario_cfg)        selected_scenario = scenario.id        tp.submit(scenario)      def submit_scenario(state):      print(\"Submitting scenario...\")      # Get the selected scenario: in this current step a single scenario is created then modified here.      scenario = tp.get(selected_scenario)        # Conversion to the right format      state_day = dt.datetime(state.day.year, state.day.month, state.day.day)        # Change the default parameters by writing in the datanodes      scenario.day.write(state_day)      scenario.n_predictions.write(int(state.n_predictions))      scenario.max_capacity.write(int(state.max_capacity))        # Execute the pipelines/code      tp.submit(scenario)        # Update the chart when we change the scenario      update_chart(state)      def update_chart(state):      # Select the right scenario and pipeline      scenario = tp.get(selected_scenario)      pipeline = scenario.pipelines[state.selected_pipeline]      # Update the chart based on this pipeline      update_predictions_dataset(state, pipeline)      if __name__ == \"__main__\":      global selected_scenario      tp.Core().run()      # Creation of a single scenario      create_scenario()      Gui(page=page_scenario_manager).run(dark_mode=False) "}
{"text": "import datetime as dt  import pandas as pd    from taipy import Config, Scope    from step_01 import path_to_csv    # Datanodes (3.1)  ## Input Data Nodes  initial_dataset_cfg = Config.configure_data_node(id=\"initial_dataset\",                                                   storage_type=\"csv\",                                                   path=path_to_csv,                                                   scope=Scope.GLOBAL)    # We assume the current day is the 26th of July 2021.  # This day can be changed to simulate multiple executions of scenarios on different days  day_cfg = Config.configure_data_node(id=\"day\", default_data=dt.datetime(2021, 7, 26))    n_predictions_cfg = Config.configure_data_node(id=\"n_predictions\", default_data=40)    max_capacity_cfg = Config.configure_data_node(id=\"max_capacity\", default_data=200)    ## Remaining Data Nodes  cleaned_dataset_cfg = Config.configure_data_node(id=\"cleaned_dataset\",                                                   validity_period=dt.timedelta(days=1),                                                   scope=Scope.GLOBAL)    predictions_cfg = Config.configure_data_node(id=\"predictions\", scope=Scope.PIPELINE)      # Functions (3.2)  def clean_data(initial_dataset: pd.DataFrame):      print(\"     Cleaning data\")      # Convert the date column to datetime      initial_dataset['Date'] = pd.to_datetime(initial_dataset['Date'])      cleaned_dataset = initial_dataset.copy()      return cleaned_dataset      def predict_baseline(cleaned_dataset: pd.DataFrame, n_predictions: int, day: dt.datetime, max_capacity: int):      print(\"     Predicting baseline\")      # Select the train data      train_dataset = cleaned_dataset[cleaned_dataset['Date'] < day]        predictions = train_dataset['Value'][-n_predictions:].reset_index(drop=True)      predictions = predictions.apply(lambda x: min(x, max_capacity))      return predictions      # Tasks (3.3)  clean_data_task_cfg = Config.configure_task(id=\"clean_data\",                                              function=clean_data,                                              input=initial_dataset_cfg,                                              output=cleaned_dataset_cfg,                                              skippable=True)    predict_baseline_task_cfg = Config.configure_task(id=\"predict_baseline\",                                                    function=predict_baseline,                                                    input=[cleaned_dataset_cfg, n_predictions_cfg, day_cfg,                                                           max_capacity_cfg],                                                    output=predictions_cfg) "}
{"text": "from step_05 import *  from step_06 import scenario_cfg    from taipy import Config    # Set the list of pipelines names  # It will be used in a selector of pipelines  pipeline_selector = [\"baseline\", \"ml\"]  selected_pipeline = pipeline_selector[0]    scenario_page = page + \"\"\"  Select the pipeline  <|{selected_pipeline}|selector|lov={pipeline_selector}|> <|Update chart|button|on_action=update_chart|>    <|{predictions_dataset}|chart|x=Date|y[1]=Historical values|type[1]=bar|y[2]=Predicted values|type[2]=scatter|height=80%|width=100%|>  \"\"\"      def create_scenario():      print(\"Creating scenario...\")      scenario = tp.create_scenario(scenario_cfg)      scenario = submit_scenario(scenario)      return scenario      def submit_scenario(scenario):      print(\"Submitting scenario...\")      tp.submit(scenario)      return scenario      def update_chart(state):      print(\"'Update chart' button clicked\")      # Select the right pipeline      pipeline = scenario.pipelines[state.selected_pipeline]        # Update the chart based on this pipeline      # It is the same function as created before in step_5      update_predictions_dataset(state, pipeline)      if __name__ == \"__main__\":      # Delete all entities      Config.configure_global_app(clean_entities_enabled=True)      tp.clean_all_entities()      tp.Core().run()      # Creation of our first scenario      scenario = create_scenario()      Gui(page=scenario_page).run(dark_mode=False) "}
{"text": "# For the sake of clarity, we have used an AutoRegressive model rather than a pure ML model such as:  # Random Forest, Linear Regression, LSTM, etc     from statsmodels.tsa.ar_model import AutoReg    from taipy import Config    from step_04 import *  from step_03 import cleaned_dataset_cfg, n_predictions_cfg, day_cfg, max_capacity_cfg, predictions_cfg, pd, dt      # This is the function that will be used by the task  def predict_ml(cleaned_dataset: pd.DataFrame, n_predictions: int, day: dt.datetime, max_capacity: int):      print(\"     Predicting with ML\")      # Select the train data      train_dataset = cleaned_dataset[cleaned_dataset[\"Date\"] < day]        # Fit the AutoRegressive model      model = AutoReg(train_dataset[\"Value\"], lags=7).fit()        # Get the n_predictions forecasts      predictions = model.forecast(n_predictions).reset_index(drop=True)      predictions = predictions.apply(lambda x: min(x, max_capacity))      return predictions      # Create the task configuration of the predict_ml function.  ## We use the same input and ouput as the previous predict_baseline task but we change the funtion  predict_ml_task_cfg = Config.configure_task(id=\"predict_ml\",                                              function=predict_ml,                                              input=[cleaned_dataset_cfg, n_predictions_cfg, day_cfg, max_capacity_cfg],                                              output=predictions_cfg)    # Create the new pipeline that will clean and predict with the ml model  ml_pipeline_cfg = Config.configure_pipeline(id=\"ml\", task_configs=[clean_data_task_cfg, predict_ml_task_cfg])    # Configure our scenario which is our business problem.  scenario_cfg = Config.configure_scenario(id=\"scenario\", pipeline_configs=[baseline_pipeline_cfg, ml_pipeline_cfg])    # The configuration is now complete    if __name__ == \"__main__\":      tp.Core().run()      # Create the scenario      scenario = tp.create_scenario(scenario_cfg)      # Execute it      tp.submit(scenario)        # Get the resulting scenario      ## Print the predictions of the two pipelines (baseline and ml)      print(\"\\nBaseline predictions\\n\", scenario.baseline.predictions.read())      print(\"\\nMachine Learning predictions\\n\", scenario.ml.predictions.read()) "}
{"text": "from step_01 import dataset, n_week, Gui    # Select the week based on the slider value  dataset_week = dataset[dataset[\"Date\"].dt.isocalendar().week == n_week]    page = \"\"\"  # Getting started with Taipy    Select week: *<|{n_week}|>*    <|{n_week}|slider|min=1|max=52|>    <|{dataset_week}|chart|type=bar|x=Date|y=Value|height=100%|width=100%|>  \"\"\"      # on_change is the function that is called when any variable is changed  def on_change(state, var_name: str, var_value):      if var_name == \"n_week\":          # Update the dataset when the slider is moved          state.dataset_week = dataset[dataset[\"Date\"].dt.isocalendar().week == var_value]      if __name__ == \"__main__\":      Gui(page=page).run(dark_mode=False) "}
{"text": "from step_11 import *    from sklearn.metrics import mean_absolute_error, mean_squared_error    # Initial dataset for comparison  comparison_scenario = pd.DataFrame({\"Scenario Name\": [],                                      \"RMSE baseline\": [], \"MAE baseline\": [],                                      \"RMSE ML\": [], \"MAE ML\": []})    # Indicates if the comparison is done  comparison_scenario_done = False    # Selector for metrics  metric_selector = [\"RMSE\", \"MAE\"]  selected_metric = metric_selector[0]      def compute_metrics(historical_data, predicted_data):      rmse = mean_squared_error(historical_data, predicted_data)      mae = mean_absolute_error(historical_data, predicted_data)      return rmse, mae      def compare(state):      print(\"Comparing...\")      # Initial lists for comparison      scenario_names = []      rmses_baseline = []      maes_baseline = []      rmses_ml = []      maes_ml = []        # Go through all the primary scenarios      all_scenarios = tp.get_primary_scenarios()      all_scenarios_ordered = sorted(all_scenarios, key=lambda x: x.creation_date.timestamp())        for scenario in all_scenarios_ordered:          print(f\"Scenario {scenario.name}\")          # Go through all the pipelines          for pipeline in scenario.pipelines.values():              print(f\"     Pipeline {pipeline.config_id}\")              # Get the predictions dataset with the historical data              only_prediction_dataset = create_predictions_dataset(pipeline)[-pipeline.n_predictions.read():]                # Series to compute the metrics (true values and predicted values)              historical_values = only_prediction_dataset[\"Historical values\"]              predicted_values = only_prediction_dataset[\"Predicted values\"]                # Compute the metrics for this pipeline and primary scenario              rmse, mae = compute_metrics(historical_values, predicted_values)                # Add values to the appropriate lists              if \"baseline\" in pipeline.config_id:                  rmses_baseline.append(rmse)                  maes_baseline.append(mae)              elif \"ml\" in pipeline.config_id:                  rmses_ml.append(rmse)                  maes_ml.append(mae)            scenario_names.append(scenario.creation_date.strftime(\"%A %d %b\"))        # Update comparison_scenario      state.comparison_scenario = pd.DataFrame({\"Scenario Name\": scenario_names,                                                \"RMSE baseline\": rmses_baseline,                                                \"MAE baseline\": maes_baseline,                                                \"RMSE ML\": rmses_ml,                                                \"MAE ML\": maes_ml})        # When comparison_scenario_done will be set to True,      # the part with the graphs will be finally rendered      state.comparison_scenario_done = True      # Performance page  page_performance = \"\"\"    <br/>    <|part|render={comparison_scenario_done}|    <|Table|expanded=False|expandable|  <|{comparison_scenario}|table|width=100%|>  |>    <|{selected_metric}|selector|lov={metric_selector}|dropdown|>    <|part|render={selected_metric==\"RMSE\"}|  <|{comparison_scenario}|chart|type=bar|x=Scenario Name|y[1]=RMSE baseline|y[2]=RMSE ML|height=100%|width=100%|>  |>    <|part|render={selected_metric==\"MAE\"}|  <|{comparison_scenario}|chart|type=bar|x=Scenario Name|y[1]=MAE baseline|y[2]=MAE ML|height=100%|width=100%|>  |>    |>      <center>  <|Compare primarys|button|on_action=compare|>  </center>  \"\"\"      lov_menu = [(\"Data-Visualization\", \"Data Visualization\"),              (\"Scenario-Manager\", \"Scenario Manager\"),              (\"Performance\", \"Performance\")]    # Create a menu with our pages  root_md = \"<|menu|label=Menu|lov={lov_menu}|on_action=menu_fct|>\"    pages = {\"/\":root_md,           \"Data-Visualization\":page_data_visualization,           \"Scenario-Manager\":page_scenario_manager,           \"Performance\":page_performance}      def menu_fct(state, var_name: str, fct: str, var_value: list):      # Change the value of the state.page variable in order to render the correct page      navigate(state, var_value[\"args\"][0])        if __name__ == \"__main__\":      tp.Core().run()      Gui(pages=pages).run(dark_mode=False) "}
{"text": "import numpy as np  import pandas as pd    from step_04 import tp, baseline_pipeline_cfg, dt  from step_02 import *    # Initialize the \"predictions\" dataset  predictions_dataset = pd.DataFrame(      {\"Date\": [dt.datetime(2021, 6, 1)], \"Historical values\": [np.NaN], \"Predicted values\": [np.NaN]})    # Add a button and a chart for our predictions  pipeline_page = page + \"\"\"  Press <|predict|button|on_action=predict|> to predict with default parameters (30 predictions) and June 1st as day.    <|{predictions_dataset}|chart|x=Date|y[1]=Historical values|type[1]=bar|y[2]=Predicted values|type[2]=scatter|height=80%|width=100%|>  \"\"\"      def predict(state):      print(\"'Predict' button clicked\")      pipeline = create_and_submit_pipeline()      update_predictions_dataset(state, pipeline)      def create_and_submit_pipeline():      print(\"Execution of pipeline...\")      # Create the pipeline from the pipeline config      pipeline = tp.create_pipeline(baseline_pipeline_cfg)      # Submit the pipeline (Execution)      tp.submit(pipeline)      return pipeline      def create_predictions_dataset(pipeline):      print(\"Creating predictions dataset...\")      # Read data from the pipeline      predictions = pipeline.predictions.read()      day = pipeline.day.read()      n_predictions = pipeline.n_predictions.read()      cleaned_data = pipeline.cleaned_dataset.read()        # Set arbitrarily the time window for the chart as 5 times the number of predictions      window = 5 * n_predictions        # Create the historical dataset that will be displayed      new_length = len(cleaned_data[cleaned_data[\"Date\"] < day]) + n_predictions      temp_df = cleaned_data[:new_length]      temp_df = temp_df[-window:].reset_index(drop=True)        # Create the series that will be used in the concat      historical_values = pd.Series(temp_df[\"Value\"], name=\"Historical values\")      predicted_values = pd.Series([np.NaN] * len(temp_df), name=\"Predicted values\")      predicted_values[-len(predictions):] = predictions        # Create the predictions dataset      # Columns : [Date, Historical values, Predicted values]      return pd.concat([temp_df[\"Date\"], historical_values, predicted_values], axis=1)      def update_predictions_dataset(state, pipeline):      print(\"Updating predictions dataset...\")      state.predictions_dataset = create_predictions_dataset(pipeline)      if __name__ == \"__main__\":      tp.Core().run()      Gui(page=pipeline_page).run(dark_mode=False) "}
{"text": "from taipy import Gui  import pandas as pd      def get_data(path_to_csv: str):      # pandas.read_csv() returns a pd.DataFrame      dataset = pd.read_csv(path_to_csv)      dataset[\"Date\"] = pd.to_datetime(dataset[\"Date\"])      return dataset      # Read the dataframe  path_to_csv = \"dataset.csv\"  dataset = get_data(path_to_csv)    # Initial value  n_week = 10    # Definition of the page  page = \"\"\"  # Getting started with Taipy    Week number: *<|{n_week}|>*    Interact with this slider to change the week number:  <|{n_week}|slider|min=1|max=52|>    ## Dataset:    Display the last three months of data:  <|{dataset[9000:]}|chart|type=bar|x=Date|y=Value|height=100%|>    <|{dataset}|table|height=400px|width=95%|>  \"\"\"    if __name__ == \"__main__\":      # Create a Gui object with our page content      Gui(page=page).run(dark_mode=False) "}
{"text": "from taipy import Gui    # A dark mode is available in Taipy  # However, we will use the light mode for the Getting Started  Gui(page=\"# Getting started with *Taipy*\").run(dark_mode=False) "}
{"text": "from step_09 import *    from taipy.gui import navigate    # Our first page is the original page  # (with the slider and the chart that displays a week of the historical data)  page_data_visualization = page    # Second page: create scenarios and display results  page_scenario_manager = \"\"\"  # Create your scenario    <|layout|columns=1 1 1 1|  <|  **Prediction date**\\n\\n <|{day}|date|not with_time|>  |>    <|  **Max capacity**\\n\\n <|{max_capacity}|number|>  |>    <|  **Number of predictions**\\n\\n<|{n_predictions}|number|>  |>    <|  <br/> <br/>\\n <|Create new scenario|button|on_action=create_scenario|>  |>  |>    <|part|render={len(scenario_selector) > 0}|  <|layout|columns=1 1|  <|  ## Scenario \\n <|{selected_scenario}|selector|lov={scenario_selector}|dropdown|>  |>    <|  ## Display the pipeline \\n <|{selected_pipeline}|selector|lov={pipeline_selector}|dropdown|>  |>  |>    <|{predictions_dataset}|chart|x=Date|y[1]=Historical values|type[1]=bar|y[2]=Predicted values|type[2]=scatter|height=80%|width=100%|>  |>  \"\"\"    lov_menu = [(\"Data-Visualization\", \"Data Visualization\"),              (\"Scenario-Manager\", \"Scenario Manager\")]    # Create a menu with our pages  root_md = \"<|menu|label=Menu|lov={lov_menu}|on_action=menu_fct|>\"    pages = {\"/\":root_md,           \"Data-Visualization\":page_data_visualization,           \"Scenario-Manager\":page_scenario_manager}      def menu_fct(state, var_name: str, fct: str, var_value: list):      # Change the value of the state.page variable in order to render the correct page      navigate(state, var_value[\"args\"][0])      if __name__ == \"__main__\":      tp.Core().run()      Gui(pages=pages).run(dark_mode=False) "}
{"text": "import taipy as tp    from step_03 import Config, clean_data_task_cfg, predict_baseline_task_cfg, dt    # Create the first pipeline configuration  baseline_pipeline_cfg = Config.configure_pipeline(id=\"baseline\",                                                    task_configs=[clean_data_task_cfg, predict_baseline_task_cfg])    ## Execute the \"baseline\" pipeline  if __name__ == \"__main__\":      tp.Core().run()      # Create the pipeline      baseline_pipeline = tp.create_pipeline(baseline_pipeline_cfg)      # Submit the pipeline (Execution)      tp.submit(baseline_pipeline)        # Read output data from the pipeline      baseline_predictions = baseline_pipeline.predictions.read()      print(\"Predictions of baseline algorithm\\n\", baseline_predictions) "}
{"text": "AWS_ACCESS_KEY = ''  AWS_SECRET_KEY = ''  AWS_REGION = ''  S3_BUCKET_NAME = '' "}
{"text": "import uuid  import boto3  from config import AWS_ACCESS_KEY, AWS_SECRET_KEY, AWS_REGION, S3_BUCKET_NAME    s3 = boto3.client('s3',          aws_access_key_id=AWS_ACCESS_KEY,           aws_secret_access_key=AWS_SECRET_KEY,           region_name=AWS_REGION      )    ALLOWED_FILE_TYPES = {'csv'}  S3_BUCKET_NAME = S3_BUCKET_NAME  S3_EXPIRES_IN_SECONDS = 100    def get_file_type(filename):       return '.' in filename and filename.rsplit('.', 1)[1].lower()    def is_file_type_allowed(filename):      return get_file_type(filename) in ALLOWED_FILE_TYPES    def upload_file_to_s3(file, provided_file_name):      stored_file_name = f'{str(uuid.uuid4())}.{get_file_type(provided_file_name)}'      s3.upload_fileobj(file, S3_BUCKET_NAME, stored_file_name)      return stored_file_name    def get_presigned_file_url(stored_file_name, provided_file_name):      if not stored_file_name or not provided_file_name:          return      return s3.generate_presigned_url(          'get_object',          Params = {              'Bucket': S3_BUCKET_NAME,              'Key': stored_file_name,              'ResponseContentDisposition': f\"attachment; filename = {provided_file_name}\"          },          ExpiresIn = S3_EXPIRES_IN_SECONDS      )"}
{"text": "from step_08 import *    # Get all the scenarios already created  all_scenarios = tp.get_scenarios()    # Delete the scenarios that don't have a name attribute  # All the scenarios of the previous steps do not have an associated name so they will be deleted,  # this will not be the case for those created by this step  [tp.delete(scenario.id) for scenario in all_scenarios if scenario.name is None]    # Initial variable for the scenario selector  # The list of possible values (lov) for the scenario selector is a list of tuples (scenario_id, scenario_name),  # but the selected_scenario is just used to retrieve the scenario id and what gets displayed is the name of the scenario.  scenario_selector = [(scenario.id, scenario.name) for scenario in tp.get_scenarios()]  selected_scenario = None    scenario_manager_page = page + \"\"\"  # Create your scenario    **Prediction date**\\n\\n <|{day}|date|not with_time|>    **Max capacity**\\n\\n <|{max_capacity}|number|>    **Number of predictions**\\n\\n<|{n_predictions}|number|>    <|Create new scenario|button|on_action=create_scenario|>    ## Scenario   <|{selected_scenario}|selector|lov={scenario_selector}|dropdown|>    ## Display the pipeline  <|{selected_pipeline}|selector|lov={pipeline_selector}|>    <|{predictions_dataset}|chart|x=Date|y[1]=Historical values|type[1]=bar|y[2]=Predicted values|type[2]=scatter|height=80%|width=100%|>  \"\"\"      def create_name_for_scenario(state) -> str:      name = f\"Scenario ({state.day.strftime('%A, %d %b')}; {state.max_capacity}; {state.n_predictions})\"        # Change the name if it is the same as some scenarios      if name in [s[1] for s in state.scenario_selector]:          name += f\" ({len(state.scenario_selector)})\"      return name      # Change the create_scenario function in order to change the default parameters  # and allow the creation of multiple scenarios  def create_scenario(state):      print(\"Execution of scenario...\")      # Extra information for the scenario      creation_date = state.day      name = create_name_for_scenario(state)      # Create a scenario      scenario = tp.create_scenario(scenario_cfg, creation_date=creation_date, name=name)        state.selected_scenario = (scenario.id, name)      # Submit the scenario that is currently selected      submit_scenario(state)      def submit_scenario(state):      print(\"Submitting scenario...\")      # Get the currently selected scenario      scenario = tp.get(state.selected_scenario[0])        # Conversion to the right format (change?)      day = dt.datetime(state.day.year, state.day.month, state.day.day)        # Change the default parameters by writing in the Data Nodes      scenario.day.write(day)      scenario.n_predictions.write(int(state.n_predictions))      scenario.max_capacity.write(int(state.max_capacity))      scenario.creation_date = state.day        # Execute the scenario      tp.submit(scenario)        # Update the scenario selector and the scenario that is currently selected      update_scenario_selector(state, scenario)  # change list to scenario        # Update the chart directly      update_chart(state)      def update_scenario_selector(state, scenario):      print(\"Updating scenario selector...\")      # Update the scenario selector      state.scenario_selector += [(scenario.id, scenario.name)]      def update_chart(state):      # Now, the selected_scenario comes from the state, it is interactive      scenario = tp.get(state.selected_scenario[0])      pipeline = scenario.pipelines[state.selected_pipeline]      update_predictions_dataset(state, pipeline)      def on_change(state, var_name: str, var_value):      if var_name == \"n_week\":          # Update the dataset when the slider is moved          state.dataset_week = dataset[dataset[\"Date\"].dt.isocalendar().week == var_value]        elif var_name == \"selected_pipeline\" or var_name == \"selected_scenario\":          # Update the chart when the scenario or the pipeline is changed          # Check if we can read the data node to update the chart          if tp.get(state.selected_scenario[0]).predictions.read() is not None:              update_chart(state)      if __name__ == \"__main__\":      Gui(page=scenario_manager_page).run(dark_mode=False) "}
{"text": "from step_07 import *    # Initial variables  ## Initial variables for the scenario     day = dt.datetime(2021, 7, 26)  n_predictions = 40  max_capacity = 200    page_scenario_manager = page + \"\"\"  # Change your scenario    **Prediction date**\\n\\n <|{day}|date|not with_time|>    **Max capacity**\\n\\n <|{max_capacity}|number|>    **Number of predictions**\\n\\n<|{n_predictions}|number|>    <|Save changes|button|on_action={submit_scenario}|>    Select the pipeline  <|{selected_pipeline}|selector|lov={pipeline_selector}|> <|Update chart|button|on_action={update_chart}|>    <|{predictions_dataset}|chart|x=Date|y[1]=Historical values|type[1]=bar|y[2]=Predicted values|type[2]=scatter|height=80%|width=100%|>  \"\"\"      def create_scenario():      global selected_scenario        print(\"Creating scenario...\")      scenario = tp.create_scenario(scenario_cfg)        selected_scenario = scenario.id        tp.submit(scenario)      def submit_scenario(state):      print(\"Submitting scenario...\")      # Get the selected scenario: in this current step a single scenario is created then modified here.      scenario = tp.get(selected_scenario)        # Conversion to the right format      state_day = dt.datetime(state.day.year, state.day.month, state.day.day)        # Change the default parameters by writing in the datanodes      scenario.day.write(state_day)      scenario.n_predictions.write(int(state.n_predictions))      scenario.max_capacity.write(int(state.max_capacity))        # Execute the pipelines/code      tp.submit(scenario)        # Update the chart when we change the scenario      update_chart(state)      def update_chart(state):      # Select the right scenario and pipeline      scenario = tp.get(selected_scenario)      pipeline = scenario.pipelines[state.selected_pipeline]      # Update the chart based on this pipeline      update_predictions_dataset(state, pipeline)      if __name__ == \"__main__\":      global selected_scenario      # Creation of a single scenario      create_scenario()      Gui(page=page_scenario_manager).run(dark_mode=False) "}
{"text": "import datetime as dt  import pandas as pd    from taipy import Config, Scope    from step_01 import path_to_csv    # Datanodes (3.1)  ## Input Data Nodes  initial_dataset_cfg = Config.configure_data_node(id=\"initial_dataset\",                                                   storage_type=\"csv\",                                                   path=path_to_csv,                                                   scope=Scope.GLOBAL)    # We assume the current day is the 26th of July 2021.  # This day can be changed to simulate multiple executions of scenarios on different days  day_cfg = Config.configure_data_node(id=\"day\", default_data=dt.datetime(2021, 7, 26))    n_predictions_cfg = Config.configure_data_node(id=\"n_predictions\", default_data=40)    max_capacity_cfg = Config.configure_data_node(id=\"max_capacity\", default_data=200)    ## Remaining Data Nodes  cleaned_dataset_cfg = Config.configure_data_node(id=\"cleaned_dataset\",                                                   cacheable=True,                                                   validity_period=dt.timedelta(days=1),                                                   scope=Scope.GLOBAL)    predictions_cfg = Config.configure_data_node(id=\"predictions\", scope=Scope.PIPELINE)      # Functions (3.2)  def clean_data(initial_dataset: pd.DataFrame):      print(\"     Cleaning data\")      # Convert the date column to datetime      initial_dataset['Date'] = pd.to_datetime(initial_dataset['Date'])      cleaned_dataset = initial_dataset.copy()      return cleaned_dataset      def predict_baseline(cleaned_dataset: pd.DataFrame, n_predictions: int, day: dt.datetime, max_capacity: int):      print(\"     Predicting baseline\")      # Select the train data      train_dataset = cleaned_dataset[cleaned_dataset['Date'] < day]        predictions = train_dataset['Value'][-n_predictions:].reset_index(drop=True)      predictions = predictions.apply(lambda x: min(x, max_capacity))      return predictions      # Tasks (3.3)  clean_data_task_cfg = Config.configure_task(id=\"clean_data\",                                              function=clean_data,                                              input=initial_dataset_cfg,                                              output=cleaned_dataset_cfg)    predict_baseline_task_cfg = Config.configure_task(id=\"predict_baseline\",                                                    function=predict_baseline,                                                    input=[cleaned_dataset_cfg, n_predictions_cfg, day_cfg,                                                           max_capacity_cfg],                                                    output=predictions_cfg) "}
{"text": "from step_05 import *  from step_06 import scenario_cfg    from taipy import Config    # Set the list of pipelines names  # It will be used in a selector of pipelines  pipeline_selector = [\"baseline\", \"ml\"]  selected_pipeline = pipeline_selector[0]    scenario_page = page + \"\"\"  Select the pipeline  <|{selected_pipeline}|selector|lov={pipeline_selector}|> <|Update chart|button|on_action=update_chart|>    <|{predictions_dataset}|chart|x=Date|y[1]=Historical values|type[1]=bar|y[2]=Predicted values|type[2]=scatter|height=80%|width=100%|>  \"\"\"      def create_scenario():      print(\"Creating scenario...\")      scenario = tp.create_scenario(scenario_cfg)      scenario = submit_scenario(scenario)      return scenario      def submit_scenario(scenario):      print(\"Submitting scenario...\")      tp.submit(scenario)      return scenario      def update_chart(state):      print(\"'Update chart' button clicked\")      # Select the right pipeline      pipeline = scenario.pipelines[state.selected_pipeline]        # Update the chart based on this pipeline      # It is the same function as created before in step_5      update_predictions_dataset(state, pipeline)      if __name__ == \"__main__\":      # Delete all entities      Config.configure_global_app(clean_entities_enabled=True)      tp.clean_all_entities()        # Creation of our first scenario      scenario = create_scenario()      Gui(page=scenario_page).run(dark_mode=False) "}
{"text": "# For the sake of clarity, we have used an AutoRegressive model rather than a pure ML model such as:  # Random Forest, Linear Regression, LSTM, etc     from statsmodels.tsa.ar_model import AutoReg    from taipy import Config    from step_04 import *  from step_03 import cleaned_dataset_cfg, n_predictions_cfg, day_cfg, max_capacity_cfg, predictions_cfg, pd, dt      # This is the function that will be used by the task  def predict_ml(cleaned_dataset: pd.DataFrame, n_predictions: int, day: dt.datetime, max_capacity: int):      print(\"     Predicting with ML\")      # Select the train data      train_dataset = cleaned_dataset[cleaned_dataset[\"Date\"] < day]        # Fit the AutoRegressive model      model = AutoReg(train_dataset[\"Value\"], lags=7).fit()        # Get the n_predictions forecasts      predictions = model.forecast(n_predictions).reset_index(drop=True)      predictions = predictions.apply(lambda x: min(x, max_capacity))      return predictions      # Create the task configuration of the predict_ml function.  ## We use the same input and ouput as the previous predict_baseline task but we change the funtion  predict_ml_task_cfg = Config.configure_task(id=\"predict_ml\",                                              function=predict_ml,                                              input=[cleaned_dataset_cfg, n_predictions_cfg, day_cfg, max_capacity_cfg],                                              output=predictions_cfg)    # Create the new pipeline that will clean and predict with the ml model  ml_pipeline_cfg = Config.configure_pipeline(id=\"ml\", task_configs=[clean_data_task_cfg, predict_ml_task_cfg])    # Configure our scenario which is our business problem.  scenario_cfg = Config.configure_scenario(id=\"scenario\", pipeline_configs=[baseline_pipeline_cfg, ml_pipeline_cfg])    # The configuration is now complete    if __name__ == \"__main__\":      # Create the scenario      scenario = tp.create_scenario(scenario_cfg)      # Execute it      tp.submit(scenario)        # Get the resulting scenario      ## Print the predictions of the two pipelines (baseline and ml)      print(\"\\nBaseline predictions\\n\", scenario.baseline.predictions.read())      print(\"\\nMachine Learning predictions\\n\", scenario.ml.predictions.read()) "}
{"text": "from step_01 import dataset, n_week, Gui    # Select the week based on the slider value  dataset_week = dataset[dataset[\"Date\"].dt.isocalendar().week == n_week]    page = \"\"\"  # Getting started with Taipy    Select week: *<|{n_week}|>*    <|{n_week}|slider|min=1|max=52|>    <|{dataset_week}|chart|type=bar|x=Date|y=Value|height=100%|width=100%|>  \"\"\"      # on_change is the function that is called when any variable is changed  def on_change(state, var_name: str, var_value):      if var_name == \"n_week\":          # Update the dataset when the slider is moved          state.dataset_week = dataset[dataset[\"Date\"].dt.isocalendar().week == var_value]      if __name__ == \"__main__\":      Gui(page=page).run(dark_mode=False) "}
{"text": "from step_11 import *    from sklearn.metrics import mean_absolute_error, mean_squared_error    # Initial dataset for comparison  comparison_scenario = pd.DataFrame({\"Scenario Name\": [],                                      \"RMSE baseline\": [], \"MAE baseline\": [],                                      \"RMSE ML\": [], \"MAE ML\": []})    # Indicates if the comparison is done  comparison_scenario_done = False    # Selector for metrics  metric_selector = [\"RMSE\", \"MAE\"]  selected_metric = metric_selector[0]      def compute_metrics(historical_data, predicted_data):      rmse = mean_squared_error(historical_data, predicted_data)      mae = mean_absolute_error(historical_data, predicted_data)      return rmse, mae      def compare(state):      print(\"Comparing...\")      # Initial lists for comparison      scenario_names = []      rmses_baseline = []      maes_baseline = []      rmses_ml = []      maes_ml = []        # Go through all the primary scenarios      all_scenarios = tp.get_primary_scenarios()      all_scenarios_ordered = sorted(all_scenarios, key=lambda x: x.creation_date.timestamp())        for scenario in all_scenarios_ordered:          print(f\"Scenario {scenario.name}\")          # Go through all the pipelines          for pipeline in scenario.pipelines.values():              print(f\"     Pipeline {pipeline.config_id}\")              # Get the predictions dataset with the historical data              only_prediction_dataset = create_predictions_dataset(pipeline)[-pipeline.n_predictions.read():]                # Series to compute the metrics (true values and predicted values)              historical_values = only_prediction_dataset[\"Historical values\"]              predicted_values = only_prediction_dataset[\"Predicted values\"]                # Compute the metrics for this pipeline and primary scenario              rmse, mae = compute_metrics(historical_values, predicted_values)                # Add values to the appropriate lists              if \"baseline\" in pipeline.config_id:                  rmses_baseline.append(rmse)                  maes_baseline.append(mae)              elif \"ml\" in pipeline.config_id:                  rmses_ml.append(rmse)                  maes_ml.append(mae)            scenario_names.append(scenario.creation_date.strftime(\"%A %d %b\"))        # Update comparison_scenario      state.comparison_scenario = pd.DataFrame({\"Scenario Name\": scenario_names,                                                \"RMSE baseline\": rmses_baseline,                                                \"MAE baseline\": maes_baseline,                                                \"RMSE ML\": rmses_ml,                                                \"MAE ML\": maes_ml})        # When comparison_scenario_done will be set to True,      # the part with the graphs will be finally rendered      state.comparison_scenario_done = True      # Performance page  page_performance = \"\"\"    <br/>    <|part|render={comparison_scenario_done}|    <|Table|expanded=False|expandable|  <|{comparison_scenario}|table|width=100%|>  |>    <|{selected_metric}|selector|lov={metric_selector}|dropdown|>    <|part|render={selected_metric==\"RMSE\"}|  <|{comparison_scenario}|chart|type=bar|x=Scenario Name|y[1]=RMSE baseline|y[2]=RMSE ML|height=100%|width=100%|>  |>    <|part|render={selected_metric==\"MAE\"}|  <|{comparison_scenario}|chart|type=bar|x=Scenario Name|y[1]=MAE baseline|y[2]=MAE ML|height=100%|width=100%|>  |>    |>      <center>  <|Compare primarys|button|on_action=compare|>  </center>  \"\"\"    # Add the page_performance section to the menu  multi_pages = \"\"\"  <|menu|label=Menu|lov={[\"Data Visualization\", \"Scenario Manager\", \"Performance\"]}|on_action=menu_fct|>    <|part|render={page==\"Data Visualization\"}|\"\"\" + page_data_visualization + \"\"\"|>  <|part|render={page==\"Scenario Manager\"}|\"\"\" + page_scenario_manager + \"\"\"|>  <|part|render={page==\"Performance\"}|\"\"\" + page_performance + \"\"\"|>  \"\"\"    if __name__ == \"__main__\":      Gui(page=multi_pages).run(dark_mode=False) "}
{"text": "import numpy as np  import pandas as pd    from step_04 import tp, baseline_pipeline_cfg, dt  from step_02 import *    # Initialize the \"predictions\" dataset  predictions_dataset = pd.DataFrame(      {\"Date\": [dt.datetime(2021, 6, 1)], \"Historical values\": [np.NaN], \"Predicted values\": [np.NaN]})    # Add a button and a chart for our predictions  pipeline_page = page + \"\"\"  Press <|predict|button|on_action=predict|> to predict with default parameters (30 predictions) and June 1st as day.    <|{predictions_dataset}|chart|x=Date|y[1]=Historical values|type[1]=bar|y[2]=Predicted values|type[2]=scatter|height=80%|width=100%|>  \"\"\"      def predict(state):      print(\"'Predict' button clicked\")      pipeline = create_and_submit_pipeline()      update_predictions_dataset(state, pipeline)      def create_and_submit_pipeline():      print(\"Execution of pipeline...\")      # Create the pipeline from the pipeline config      pipeline = tp.create_pipeline(baseline_pipeline_cfg)      # Submit the pipeline (Execution)      tp.submit(pipeline)      return pipeline      def create_predictions_dataset(pipeline):      print(\"Creating predictions dataset...\")      # Read data from the pipeline      predictions = pipeline.predictions.read()      day = pipeline.day.read()      n_predictions = pipeline.n_predictions.read()      cleaned_data = pipeline.cleaned_dataset.read()        # Set arbitrarily the time window for the chart as 5 times the number of predictions      window = 5 * n_predictions        # Create the historical dataset that will be displayed      new_length = len(cleaned_data[cleaned_data[\"Date\"] < day]) + n_predictions      temp_df = cleaned_data[:new_length]      temp_df = temp_df[-window:].reset_index(drop=True)        # Create the series that will be used in the concat      historical_values = pd.Series(temp_df[\"Value\"], name=\"Historical values\")      predicted_values = pd.Series([np.NaN] * len(temp_df), name=\"Predicted values\")      predicted_values[-len(predictions):] = predictions        # Create the predictions dataset      # Columns : [Date, Historical values, Predicted values]      return pd.concat([temp_df[\"Date\"], historical_values, predicted_values], axis=1)      def update_predictions_dataset(state, pipeline):      print(\"Updating predictions dataset...\")      state.predictions_dataset = create_predictions_dataset(pipeline)      if __name__ == \"__main__\":      Gui(page=pipeline_page).run(dark_mode=False) "}
{"text": "from taipy import Gui  import pandas as pd      def get_data(path_to_csv: str):      # pandas.read_csv() returns a pd.DataFrame      dataset = pd.read_csv(path_to_csv)      dataset[\"Date\"] = pd.to_datetime(dataset[\"Date\"])      return dataset      # Read the dataframe  path_to_csv = \"dataset.csv\"  dataset = get_data(path_to_csv)    # Initial value  n_week = 10    # Definition of the page  page = \"\"\"  # Getting started with Taipy    Week number: *<|{n_week}|>*    Interact with this slider to change the week number:  <|{n_week}|slider|min=1|max=52|>    ## Dataset:    Display the last three months of data:  <|{dataset[9000:]}|chart|type=bar|x=Date|y=Value|height=100%|>    <|{dataset}|table|height=400px|width=95%|>  \"\"\"    if __name__ == \"__main__\":      # Create a Gui object with our page content      Gui(page=page).run(dark_mode=False) "}
{"text": "from taipy import Gui    # A dark mode is available in Taipy  # However, we will use the light mode for the Getting Started  Gui(page=\"# Getting started with *Taipy*\").run(dark_mode=False) "}
{"text": "from step_09 import *    # Our first page is the original page  # (with the slider and the chart that displays a week of the historical data)  page_data_visualization = page    # Second page: create scenarios and display results  page_scenario_manager = \"\"\"  # Create your scenario    <|layout|columns=1 1 1 1|  <|  **Prediction date**\\n\\n <|{day}|date|not with_time|>  |>    <|  **Max capacity**\\n\\n <|{max_capacity}|number|>  |>    <|  **Number of predictions**\\n\\n<|{n_predictions}|number|>  |>    <|  <br/> <br/>\\n <|Create new scenario|button|on_action=create_scenario|>  |>  |>    <|part|render={len(scenario_selector) > 0}|  <|layout|columns=1 1|  <|  ## Scenario \\n <|{selected_scenario}|selector|lov={scenario_selector}|dropdown|>  |>    <|  ## Display the pipeline \\n <|{selected_pipeline}|selector|lov={pipeline_selector}|dropdown|>  |>  |>    <|{predictions_dataset}|chart|x=Date|y[1]=Historical values|type[1]=bar|y[2]=Predicted values|type[2]=scatter|height=80%|width=100%|>  |>  \"\"\"    # Create a menu with our pages  multi_pages = \"\"\"  <|menu|label=Menu|lov={[\"Data Visualization\", \"Scenario Manager\"]}|on_action=menu_fct|>    <|part|render={page==\"Data Visualization\"}|\"\"\" + page_data_visualization + \"\"\"|>  <|part|render={page==\"Scenario Manager\"}|\"\"\" + page_scenario_manager + \"\"\"|>  \"\"\"    # The initial page is the \"Data Visualization\" page  page = \"Data Visualization\"      def menu_fct(state, var_name: str, fct: str, var_value: list):      # Change the value of the state.page variable in order to render the correct page      state.page = var_value[\"args\"][0]      if __name__ == \"__main__\":      Gui(page=multi_pages).run(dark_mode=False) "}
{"text": "import taipy as tp    from step_03 import Config, clean_data_task_cfg, predict_baseline_task_cfg, dt    # Create the first pipeline configuration  baseline_pipeline_cfg = Config.configure_pipeline(id=\"baseline\",                                                    task_configs=[clean_data_task_cfg, predict_baseline_task_cfg])    ## Execute the \"baseline\" pipeline  if __name__ == \"__main__\":      # Create the pipeline      baseline_pipeline = tp.create_pipeline(baseline_pipeline_cfg)      # Submit the pipeline (Execution)      tp.submit(baseline_pipeline)        # Read output data from the pipeline      baseline_predictions = baseline_pipeline.predictions.read()      print(\"Predictions of baseline algorithm\\n\", baseline_predictions) "}
{"text": "from taipy.gui import Gui  from keras.models import load_model  from PIL import Image  import numpy as np    class_names = {      0: 'airplane',      1: 'automobile',      2: 'bird',      3: 'cat',      4: 'deer',      5: 'dog',      6: 'frog',      7: 'horse',      8: 'ship',      9: 'truck',  }    model = load_model(\"Neural Network Notebook/Cifar10Model.keras\")    def predict_image(model, path_to_img):      img = Image.open(path_to_img)      img = img.convert(\"RGB\")      img = img.resize((32, 32))      data = np.asarray(img)      data = data / 255      probs = model.predict(np.array([data])[:1])        top_prob = probs.max()      top_pred = class_names[np.argmax(probs)]            return top_prob, top_pred        content = \"\"  img_path = \"placeholder_image.png\"  prob = 0  pred = \"\"    index = \"\"\"  <|text-center|  <|{\"logo.png\"}|image|width=16vw|>    <|{content}|file_selector|extensions=.png|>  select an image from your file system    <|{pred}|>    <|{img_path}|image|>    <|{prob}|indicator|value={prob}|min=0|max=100|width=25vw|>  >  \"\"\"    def on_change(state, var_name, var_val):      if var_name == \"content\":          top_prob, top_pred = predict_image(model, var_val)          state.prob = round(top_prob * 100)          state.pred = \"this is a \" + top_pred          state.img_path = var_val      #print(var_name, var_val)    app = Gui(page=index)    if __name__ == \"__main__\":      app.run(use_reloader=True)"}
{"text": "import pandas as pd  from sklearn.model_selection import train_test_split  from sklearn.ensemble import RandomForestRegressor  from sklearn.compose import ColumnTransformer  from sklearn.pipeline import Pipeline  from sklearn.preprocessing import OneHotEncoder  from sklearn.metrics import mean_squared_error  import numpy as np  # Import numpy for RMSE calculation  from prophet import Prophet      def build_message(name: str):      return f\"Hello {name}!\"    def clean_data(initial_dataset: pd.DataFrame):      return initial_dataset    def retrained_model(cleaned_dataset: pd.DataFrame):      # Split the dataset into features (X) and target (y)      X = cleaned_dataset.drop('Claim_Amount', axis=1)      y = cleaned_dataset['Claim_Amount']        # Split the data into training and testing sets      X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)        # Define the categorical columns for one-hot encoding      categorical_cols = ['Procedure_Code', 'Diagnosis_Code', 'Provider_Specialty', 'Insurance_Plan']        # Create a column transformer      preprocessor = ColumnTransformer(          transformers=[              ('cat', OneHotEncoder(drop='first'), categorical_cols)          ],          remainder='passthrough'      )        # Create a pipeline with preprocessing and the Random Forest Regressor      model = Pipeline([          ('preprocessor', preprocessor),          ('regressor', RandomForestRegressor(n_estimators=100, random_state=42))      ])        # Fit the model on the training data      model.fit(X_train, y_train)        # Make predictions on the test set      predictions = model.predict(X_test)        # Calculate Mean Squared Error (MSE)      mse = mean_squared_error(y_test, predictions)        # Calculate Root Mean Squared Error (RMSE)      rmse = np.sqrt(mse)        # Print the RMSE      print(f\"Mean Squared Error: {mse}\")      print(f\"Root Mean Squared Error (RMSE): {rmse}\")            return model    def predict(model):      # Example: Make a prediction for a new patient      new_patient_data = pd.DataFrame({          'Procedure_Code': ['CPT456'],          'Diagnosis_Code': ['ICD-10-B'],          'Provider_Specialty': ['Orthopedics'],          'Patient_Age': [35],          'Insurance_Plan': ['PPO'],          'Deductible': [200],          'Copayment': [30],          'Coinsurance': [20],      }, index=[0])        # Predict the claim amount for the new patient      new_patient_claim = model.predict(new_patient_data)      print(f\"Predicted Claim Amount for New Patient: ${new_patient_claim[0]:.2f}\")"}
{"text": "import taipy as tp  from taipy.core.config import Config    Config.load('my_config.toml')    scenario_cfg = Config.scenarios['scenario']    if __name__ == '__main__':      tp.Core().run()        scenario_1 = tp.create_scenario(scenario_cfg)      print(\"submitting\")        scenario_1.submit()      print(\"submit shit ayyindhi\") "}
{"text": "from taipy.gui import Html    html_page = Html(\"\"\"      <head>          <script src=\"https://maps.googleapis.com/maps/api/js?key=AIzaSyBIeklfsRu1yz97lY2gJzWHJcmrd7lx2zU&libraries=places\"></script>          <script type=\"text/javascript\">              function initialize() {                  geocoder = new google.maps.Geocoder();                  var mapOptions = {                  }                  var locations = [\"12836 University Club Dr\", \"2204 Fitness Club Way\"];                  var markers = [];                  var iterator = 0;                  var bounds = new google.maps.LatLngBounds();                    for (var i = 0; i < locations.length; i++) {                      setTimeout(function() {                              geocoder.geocode({'address': locations[iterator]}, function(results, status){                          if (status == google.maps.GeocoderStatus.OK) {                              var marker = new google.maps.Marker({                                  map: map,                                  position: results[0].geometry.location,                                  animation: google.maps.Animation.DROP                              });                              bounds.extend(marker.getPosition());                              map.fitBounds(bounds);                          } else {                              console.log('Geocode was not successful for the following reason: ' + status);                          }                      });                      iterator++;                        }, i * 250);                  }                  var map = new google.maps.Map(document.getElementById(\"map-canvas\"), mapOptions);                        }              google.maps.event.addDomListener(window, 'load', initialize);          </script>      </head>      <body>          <div id=\"map-canvas\" style=\"width: 100%; height: 400px;\"></div>      </body>  \"\"\")"}
{"text": "from geopy.geocoders import Nominatim  import folium    user_agent = \"geoapiExercises/1.0 AIzaSyBIeklfsRu1yz97lY2gJzWHJcmrd7lx2zU\"    # Initialize the geocoder with the user agent  geolocator = Nominatim(user_agent=user_agent, timeout=10)  # List of locations to geocode  locations = [\"Denver, CO, United States\", \"New York, NY, United States\", \"Los Angeles, CA, United States\"]    # Create an empty map  map_location = folium.Map(location=[0, 0], zoom_start=5)    # Iterate through the list of locations  for location in locations:      # Perform geocoding      location_info = geolocator.geocode(location)        if location_info:          # Extract latitude and longitude          latitude = location_info.latitude          longitude = location_info.longitude            # Add a marker for the geocoded location          folium.Marker([latitude, longitude], popup=location).add_to(map_location)      else:          print(f\"Geocoding was not successful for the location: {location}\")    # Save or display the map (as an HTML file)  map_location.save(\"geocoded_locations_map.html\")    print(\"Map created and saved as 'geocoded_locations_map.html'\") "}
{"text": "from taipy.gui import Gui, notify  import pandas as pd  import yfinance as yf  from taipy.config import Config  import taipy as tp   import datetime as dt  from taipy import Core  from show_hospitals_map import html_page  from flask import Flask, request, session, jsonify, redirect, render_template  from flask_restful import Api, Resource  import requests    Config.load(\"config_model_train.toml\")  scenario_cfg = Config.scenarios['stock']  tickers = yf.Tickers(\"msft aapl goog\")    root_md = \"<|navbar|>\"    property_chart = {      \"type\": \"lines\",      \"x\": \"Date\",      \"y[1]\": \"Open\",      \"y[2]\": \"Close\",      \"y[3]\": \"High\",      \"y[4]\": \"Low\",      \"color[1]\": \"green\",      \"color[2]\": \"grey\",      \"color[3]\": \"red\",      \"color[4]\": \"yellow\",  }  df = pd.DataFrame([], columns=[\"Date\", \"High\", \"Low\", \"Open\", \"Close\"])  df_pred = pd.DataFrame([], columns = ['Date','Close_Prediction'])    stock = \"\"  stock_text = \"No Stock to Show\"  chart_text = \"No Chart to Show\"  stocks = []      page = \"\"\"  # Stock Portfolio    ### Choose the stock to show  <|toggle|theme|>    <|layout|columns=1 1|  <|  <|{stock_text}|>    <|{stock}|selector|lov=MSFT;AAPL;GOOG;Reset|dropdown|>    <|Press for Stock|button|on_action=on_button_action|>  <|Get the future predictions|button|on_action=get_predictions|>  |>    <|{stock}  <|{chart_text}|>  <|{df}|chart|properties={property_chart}|>  |>    |>  \"\"\"    pages = {      \"/\" : root_md,      \"home\" : page,      \"claim\": \"empty page\"  }    def on_button_action(state):      if state.stock == \"Reset\":          state.stock_text = \"No Stock to Show\"          state.chart_text = \"No Chart to Show\"          state.df = pd.DataFrame([], columns=[\"Date\", \"High\", \"Low\", \"Open\", \"Close\"])          state.df_pred = pd.DataFrame([], columns = ['Date','Close_Prediction'])          state.pred_text = \"No Prediction to Show\"      else:          state.stock_text = f\"The stock is {state.stock}\"          state.chart_text = f\"Monthly history of stock {state.stock}\"          state.df = tickers.tickers[state.stock].history().reset_index()          state.df.to_csv(f\"{stock}.csv\", index=False)        def get_predictions(state):            scenario_stock = tp.create_scenario(scenario_cfg)      scenario_stock.initial_dataset.path = f\"{stock}\".csv      notify(state, 'success', 'camehere')      scenario_stock.write(state.df)      tp.submit(scenario_stock)      state.df_pred = scenario_stock.predictions.read()      state.df_pred.to_csv(\"pred.csv\", index=False)    tp.Core().run()  # Gui(pages=pages).run(use_reloader=True)      app = Flask(__name__)  # app = Flask(__name__)  app.secret_key = \"your_secret_key\"  # Set a secret key for session management  api = Api(app)    class SignupResource(Resource):      def get(self):          return redirect(\"/signup.html\")            def post(self):          SIGNUP_API_URL = \"https://health-insurance-rest-apis.onrender.com/api/signup\"          signup_data = {              'username': request.form['username'],              'password': request.form['password'],              'email': request.form['email']          }          headers = {              'Content-Type': 'application/json'          }          print(signup_data)          response = requests.post(SIGNUP_API_URL, headers=headers, json=signup_data)          print(\"response\", response)          if response.status_code == 200:              return redirect(\"/login.html\")          else:              return 'Signup Failed'    # Login Resource  class LoginResource(Resource):      def get(self):          \"\"\"          Return a simple login page HTML          \"\"\"          return redirect(\"/login.html\")      def post(self):          email = request.form['email']          password = request.form['password']          auth_data = {              'username': email,              'password': password          }          AUTH_API_URL = \"https://health-insurance-rest-apis.onrender.com/api/login\"          response = requests.post(AUTH_API_URL, json=auth_data)          if response.status_code == 200:              auth_data = response.json()              access_token = auth_data.get('access_token')              refresh_token = auth_data.get('refresh_token')                # Store tokens in the session              session['access_token'] = access_token              session['refresh_token'] = refresh_token                return redirect(\"/home\")          else:              return 'Login failed', 401    # Protected Resource  class ProtectedResource(Resource):      def get(self):          # Check if the JWT token is present in the session          if 'jwt_token' in session:              jwt_token = session['jwt_token']                # You can add logic here to verify the JWT token if needed              # For simplicity, we assume the token is valid                return {'message': 'Access granted for protected route', 'jwt_token': jwt_token}, 200          else:              return {'message': 'Access denied'}, 401    print(\"registered the apis\")  # Add resources to the API  api.add_resource(LoginResource, '/login')  api.add_resource(ProtectedResource, '/protected')  api.add_resource(SignupResource, '/signup')    @app.before_request  def check_access_token():      # print ('access_token' in session, \"checkIt\")      if request.endpoint != 'login' and 'access_token' not in session:      #     # Redirect to the login page if not on the login route and no access_token is in the session      #     print(request.endpoint, \"endpoint\")          return redirect(\"/login\")    gui = Gui(pages=pages, flask=app).run(debug=False) "}
{"text": "from taipy import Config, Scope  import pandas as pd  from prophet import Prophet  from functions import *      # Input Data Nodes  initial_dataset_cfg = Config.configure_data_node(id=\"initial_dataset\",                                                   storage_type=\"csv\",                                                   default_path='df.csv')    cleaned_dataset_cfg = Config.configure_data_node(id=\"cleaned_dataset\")            clean_data_task_cfg = Config.configure_task(id=\"clean_data_task\",                                              function=clean_data,                                              input=initial_dataset_cfg,                                              output=cleaned_dataset_cfg,                                              skippable=True)      model_training_cfg = Config.configure_data_node(id=\"model_output\")        predictions_cfg = Config.configure_data_node(id=\"predictions\")            model_training_task_cfg = Config.configure_task(id=\"model_retraining_task\",                                                  function=retrained_model,                                                  input=cleaned_dataset_cfg,                                                  output=model_training_cfg,                                                  skippable=True)    predict_task_cfg = Config.configure_task(id=\"predict_task\",                                           function=predict,                                           input=model_training_cfg,                                           output=predictions_cfg,                                             skippable=True)      # Create the first pipeline configuration  # retraining_model_pipeline_cfg = Config.configure_pipeline(  #     id=\"model_retraining_pipeline\",  #     task_configs=[clean_data_task_cfg, model_training_task_cfg],  # )      # Run the Taipy Core service  # import taipy as tp    # # Run of the Taipy Core service  # tp.Core().run()    # # Create the pipeline  # retrain_pipeline = tp.create_pipeline(retraining_model_pipeline_cfg)    # # Submit the pipeline  # tp.submit(retrain_pipeline)      # tp.Core().stop()    scenario_cfg = Config.configure_scenario_from_tasks(id=\"stock\",                                                      task_configs=[clean_data_task_cfg,                                                      model_training_task_cfg,                                                      predict_task_cfg])      # tp.Core().run()  # tp.submit(scenario_cfg)    Config.export(\"config_model_train.toml\")"}
{"text": "from taipy import Config  from functions import build_message          name_data_node_cfg = Config.configure_data_node(id=\"name\")  message_data_node_cfg = Config.configure_data_node(id=\"message\")  build_msg_task_cfg = Config.configure_task(\"build_msg\", build_message, name_data_node_cfg, message_data_node_cfg)  scenario_cfg = Config.configure_scenario_from_tasks(\"scenario\", task_configs=[build_msg_task_cfg])    Config.export('my_config.toml')"}
{"text": "from functools import wraps  import jwt  from flask import request, abort  from flask import current_app    def token_required(f):      @wraps(f)      def decorated(*args, **kwargs):          token = None          if \"Authorization\" in request.headers:              token = request.headers[\"Authorization\"].split(\" \")[1]          if not token:              return {                  \"message\": \"Authentication Token is missing!\",                  \"data\": None,                  \"error\": \"Unauthorized\"              }, 401          try:              # data=jwt.decode(token, current_app.config[\"SECRET_KEY\"], algorithms=[\"RS256\"])              print(\"got the token\")              # current_user=models.User().get_by_id(data[\"user_id\"])              current_user = 12              if current_user is None:                  return {                  \"message\": \"Invalid Authentication token!\",                  \"data\": None,                  \"error\": \"Unauthorized\"              }, 401              if not current_user[\"active\"]:                  abort(403)          except Exception as e:              return {                  \"message\": \"Something went wrong\",                  \"data\": None,                  \"error\": str(e)              }, 500            return f(current_user, *args, **kwargs)        return decorated"}
{"text": "from flask import Flask, request, session, jsonify  from flask_restful import Api, Resource    app = Flask(__name__)  app.secret_key = \"your_secret_key\"  # Set a secret key for session management  api = Api(app)    # Dummy user data for demonstration  users = {      'maneesh': {'password': 'securepassword'}  }    # Login Resource  class LoginResource(Resource):      def post(self):          data = request.get_json()          username = data.get('username')          password = data.get('password')          print(\"hello\")          # Check if user exists and password is correct          if username in users and users[username]['password'] == password:              # Simulate receiving a JWT token from a third-party API              jwt_token = \"your_received_jwt_token\"                # Store the JWT token in the session              session['jwt_token'] = jwt_token                return {'message': 'Login successful'}, 200          else:              return {'message': 'Invalid credentials'}, 401    # Protected Resource  class ProtectedResource(Resource):      def get(self):          # Check if the JWT token is present in the session          if 'jwt_token' in session:              jwt_token = session['jwt_token']                # You can add logic here to verify the JWT token if needed              # For simplicity, we assume the token is valid                return {'message': 'Access granted for protected route', 'jwt_token': jwt_token}, 200          else:              return {'message': 'Access denied'}, 401    # Add resources to the API  api.add_resource(LoginResource, '/login')  api.add_resource(ProtectedResource, '/protected')    if __name__ == '__main__':      app.run(debug=True) "}